diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..0857e09
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,51 @@
+---
+Language: Cpp
+BasedOnStyle: Microsoft
+AccessModifierOffset: -4
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: false
+AlignTrailingComments: false
+AlwaysBreakTemplateDeclarations: Yes
+BraceWrapping: 
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: true
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: false
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeLambdaBody: true
+  BeforeWhile: true
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakConstructorInitializers: AfterColon
+BreakConstructorInitializersBeforeComma: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+IncludeCategories: 
+  - Regex: '^<.*'
+    Priority: 1
+  - Regex: '^".*'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseBlocks: true
+IndentPPDirectives: BeforeHash
+InsertNewlineAtEOF: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+PointerAlignment: Left
+SpaceInEmptyParentheses: false
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+...
diff --git a/.gitmodules b/.gitmodules
index 3e4be6c..b8d7467 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -19,6 +19,6 @@
 [submodule "Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers"]
 	path = Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers
 	url = https://github.com/Microsoft/DirectX-Headers
-[submodule "ThirdParty/emhash"]
-	path = ThirdParty/emhash
-	url = https://github.com/ktprime/emhash
+[submodule "ThirdParty/concurrentqueue"]
+	path = ThirdParty/concurrentqueue
+	url = https://github.com/cameron314/concurrentqueue
\ No newline at end of file
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 49f96f4..87250ae 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,10 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <RiderCodeStyleSettings>
+      <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_PREPROCESSOR_DIRECTIVES/@EntryValue" value="Normal" type="string" />
+      <option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
+      <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_LIMIT/@EntryValue" value="150" type="long" />
+    </RiderCodeStyleSettings>
     <files>
       <extensions>
         <pair source="cc" header="h" fileNamingConvention="NONE" />
diff --git a/.idea/editor.xml b/.idea/editor.xml
index b0d69ef..9e1bfff 100644
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="BackendCodeEditorSettings">
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_PREPROCESSOR_DIRECTIVES/@EntryValue" value="Normal" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppSmartPointerVsMakeFunction/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppFunctionalStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
@@ -240,6 +241,8 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=StringLiteralTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CommentTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=IdentifierTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_LIMIT/@EntryValue" value="150" type="long" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppSmartPointerVsMakeFunction/@EntryIndexRemoved" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexRemoved" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppFunctionalStyleCast/@EntryIndexRemoved" />
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index 5d7b1f3..e5e8972 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -5,6 +5,7 @@
     <mapping directory="$PROJECT_DIR$/Coplt.Graphics.Native/D3d12/ThirdParty/D3D12MemoryAllocator" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Coplt.Graphics.Native/D3d12/ThirdParty/DirectXTK12" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/ThirdParty/concurrentqueue" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/ThirdParty/cpptrace" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/ThirdParty/emhash" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/ThirdParty/fmt" vcs="Git" />
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a61cf67..9aea6db 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,6 +30,7 @@ add_subdirectory(ThirdParty/cpptrace)
 add_subdirectory(ThirdParty/glm)
 add_subdirectory(ThirdParty/fmt)
 add_subdirectory(ThirdParty/mimalloc)
+add_subdirectory(ThirdParty/concurrentqueue)
 
 add_subdirectory(Coplt.Graphics.Native/Api)
 add_subdirectory(Coplt.Graphics.Native/D3d12)
diff --git a/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj b/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
index c43780f..6ce33f6 100644
--- a/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
+++ b/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
@@ -15,6 +15,7 @@
     <ItemGroup>
         <PackageReference Include="Coplt.Dropping" Version="0.6.0" />
         <PackageReference Include="Coplt.Mathematics" Version="0.10.0"/>
+        <PackageReference Include="Coplt.Union" Version="0.11.0" />
         <PackageReference Include="Fody" Version="6.9.1">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/Coplt.Graphics.Core/Core/Barrier.cs b/Coplt.Graphics.Core/Core/Barrier.cs
new file mode 100644
index 0000000..5e2e513
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/Barrier.cs
@@ -0,0 +1,238 @@
+using Coplt.Graphics.Native;
+using Coplt.Union;
+
+namespace Coplt.Graphics.Core;
+
+[Union]
+public partial struct Barrier
+{
+    [UnionTemplate]
+    private interface Template
+    {
+        void None();
+        GlobalBarrier Global();
+        BufferBarrier Buffer();
+        ImageBarrier Image();
+    }
+
+    public static implicit operator Barrier(GlobalBarrier value) => MakeGlobal(value);
+
+    public static implicit operator Barrier(BufferBarrier value) => MakeBuffer(value);
+
+    public static implicit operator Barrier(ImageBarrier value) => MakeImage(value);
+}
+
+public record struct GlobalBarrier(
+    ResAccess AccessBefore,
+    ResAccess AccessAfter,
+    ShaderStageFlags StagesBefore,
+    ShaderStageFlags StagesAfter
+)
+{
+    public ResAccess AccessBefore = AccessBefore;
+    public ResAccess AccessAfter = AccessAfter;
+    public ShaderStageFlags StagesBefore = StagesBefore;
+    public ShaderStageFlags StagesAfter = StagesAfter;
+}
+
+public record struct BufferBarrier(
+    IGpuResource Buffer,
+    ulong Offset,
+    ulong Size,
+    LegacyState LegacyBefore,
+    LegacyState LegacyAfter,
+    ResAccess AccessBefore,
+    ResAccess AccessAfter,
+    ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+    ShaderStageFlags StagesAfter = ShaderStageFlags.None
+)
+{
+    public IGpuResource Buffer = Buffer;
+    public ulong Offset = Offset;
+    public ulong Size = Size;
+    public LegacyState LegacyBefore = LegacyBefore;
+    public LegacyState LegacyAfter = LegacyAfter;
+    public ResAccess AccessBefore = AccessBefore;
+    public ResAccess AccessAfter = AccessAfter;
+    public ShaderStageFlags StagesBefore = StagesBefore;
+    public ShaderStageFlags StagesAfter = StagesAfter;
+
+    public BufferBarrier(
+        IGpuResource Buffer,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None
+    ) : this(
+        Buffer, 0, Buffer.Size,
+        LegacyBefore, LegacyAfter, AccessBefore, AccessAfter, StagesBefore, StagesAfter
+    ) { }
+
+    public BufferBarrier(
+        IGpuResource Buffer,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter
+    ) : this(
+        Buffer, 0, Buffer.Size,
+        LegacyBefore, LegacyAfter, default, default, default, default
+    ) { }
+
+    public BufferBarrier(
+        IGpuResource Buffer,
+        ulong Offset,
+        ulong Size,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter
+    ) : this(
+        Buffer, Offset, Size,
+        LegacyBefore, LegacyAfter, default, default, default, default
+    ) { }
+
+    public BufferBarrier(
+        IGpuResource Buffer,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None
+    ) : this(
+        Buffer, 0, Buffer.Size,
+        default, default, AccessBefore, AccessAfter, StagesBefore, StagesAfter
+    ) { }
+
+    public BufferBarrier(
+        IGpuResource Buffer,
+        ulong Offset,
+        ulong Size,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None
+    ) : this(
+        Buffer, Offset, Size,
+        default, default, AccessBefore, AccessAfter, StagesBefore, StagesAfter
+    ) { }
+}
+
+public record struct ImageBarrier(
+    IGpuResource Image,
+    SubResourceRange SubResourceRange,
+    LegacyState LegacyBefore,
+    LegacyState LegacyAfter,
+    ResLayout LayoutBefore,
+    ResLayout LayoutAfter,
+    ResAccess AccessBefore,
+    ResAccess AccessAfter,
+    ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+    ShaderStageFlags StagesAfter = ShaderStageFlags.None,
+    ImageBarrierFlags Flags = ImageBarrierFlags.None
+)
+{
+    public IGpuResource Image = Image;
+    public SubResourceRange SubResourceRange = SubResourceRange;
+    public LegacyState LegacyBefore = LegacyBefore;
+    public LegacyState LegacyAfter = LegacyAfter;
+    public ResLayout LayoutBefore = LayoutBefore;
+    public ResLayout LayoutAfter = LayoutAfter;
+    public ResAccess AccessBefore = AccessBefore;
+    public ResAccess AccessAfter = AccessAfter;
+    public ShaderStageFlags StagesBefore = StagesBefore;
+    public ShaderStageFlags StagesAfter = StagesAfter;
+    public ImageBarrierFlags Flags = Flags;
+
+    public ImageBarrier(
+        IGpuResource Image,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter,
+        ResLayout LayoutBefore,
+        ResLayout LayoutAfter,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None,
+        ImageBarrierFlags Flags = ImageBarrierFlags.None
+    ) : this(
+        Image, new(Image),
+        LegacyBefore, LegacyAfter, LayoutBefore, LayoutAfter, AccessBefore, AccessAfter, StagesBefore, StagesAfter,
+        Flags
+    ) { }
+
+    public ImageBarrier(
+        IGpuResource Image,
+        SubResourceRange SubResourceRange,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter,
+        ImageBarrierFlags Flags = ImageBarrierFlags.None
+    ) : this(
+        Image, SubResourceRange,
+        LegacyBefore, LegacyAfter, default, default, default, default, default, default, Flags
+    ) { }
+
+    public ImageBarrier(
+        IGpuResource Image,
+        LegacyState LegacyBefore,
+        LegacyState LegacyAfter,
+        ImageBarrierFlags Flags = ImageBarrierFlags.None
+    ) : this(
+        Image, new(Image),
+        LegacyBefore, LegacyAfter, default, default, default, default, default, default, Flags
+    ) { }
+
+    public ImageBarrier(
+        IGpuResource Image,
+        ResLayout LayoutBefore,
+        ResLayout LayoutAfter,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None,
+        ImageBarrierFlags Flags = ImageBarrierFlags.None
+    ) : this(
+        Image, new(Image),
+        default, default, LayoutBefore, LayoutAfter, AccessBefore, AccessAfter, StagesBefore, StagesAfter, Flags
+    ) { }
+
+    public ImageBarrier(
+        IGpuResource Image,
+        SubResourceRange SubResourceRange,
+        ResLayout LayoutBefore,
+        ResLayout LayoutAfter,
+        ResAccess AccessBefore,
+        ResAccess AccessAfter,
+        ShaderStageFlags StagesBefore = ShaderStageFlags.None,
+        ShaderStageFlags StagesAfter = ShaderStageFlags.None,
+        ImageBarrierFlags Flags = ImageBarrierFlags.None
+    ) : this(
+        Image, SubResourceRange,
+        default, default, LayoutBefore, LayoutAfter, AccessBefore, AccessAfter, StagesBefore, StagesAfter, Flags
+    ) { }
+}
+
+[Flags]
+public enum ImageBarrierFlags : uint
+{
+    None,
+    Discard = 1 << 0,
+    CrossQueue = 1 << 1,
+}
+
+public record struct SubResourceRange(
+    uint IndexOrFirstMipLevel,
+    uint NumMipLevels,
+    uint FirstArraySlice,
+    uint NumArraySlices,
+    uint FirstPlane,
+    uint NumPlanes
+)
+{
+    public uint IndexOrFirstMipLevel = IndexOrFirstMipLevel;
+    public uint NumMipLevels = NumMipLevels;
+    public uint FirstArraySlice = FirstArraySlice;
+    public uint NumArraySlices = NumArraySlices;
+    public uint FirstPlane = FirstPlane;
+    public uint NumPlanes = NumPlanes;
+
+    public SubResourceRange(IGpuResource Image)
+        : this(0, Image.MipLevels, 0, Image.DepthOrLength, 0, Image.Planes) { }
+}
diff --git a/Coplt.Graphics.Core/Core/CommandList.cs b/Coplt.Graphics.Core/Core/CommandList.cs
index f164ab7..f5b1c4f 100644
--- a/Coplt.Graphics.Core/Core/CommandList.cs
+++ b/Coplt.Graphics.Core/Core/CommandList.cs
@@ -2,15 +2,12 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Coplt.Graphics.Native;
+using Coplt.Graphics.Utilities;
+using Coplt.Union;
+using static Coplt.Graphics.Core.CommandList;
 
 namespace Coplt.Graphics.Core;
 
-public enum CommandFlags : uint
-{
-    None = 0,
-    DontTransition = 1 << 0,
-}
-
 public enum DispatchType : byte
 {
     Auto,
@@ -18,32 +15,307 @@ public enum DispatchType : byte
     Mesh,
 }
 
+/// <summary>
+/// 命令列表，不支持多线程访问
+/// </summary>
 public sealed unsafe class CommandList
 {
+    #region Struct
+
+    internal struct ResourceState(int SlotIndex, IGpuResource Resource)
+    {
+        public readonly int SlotIndex = SlotIndex;
+        public readonly IGpuResource Resource = Resource;
+        public int CurrentBarrierIndex = -1;
+        public int CurrentBarrierCmdIndex = -1;
+        public int LastUsedBarrierCmdIndex = -1;
+        public bool First = true;
+
+        public void MarkUse(CommandList self)
+        {
+            LastUsedBarrierCmdIndex = self.m_current_barrier_cmd_index;
+        }
+
+        public void ReqState(
+            CommandList self,
+            FResLayout Layout,
+            FResAccess Access,
+            FShaderStageFlags Stages,
+            FLegacyState Legacy,
+            bool? CrossQueue = null,
+            FImageBarrierFlags ImageFlags = FImageBarrierFlags.None
+        ) => ReqState(
+            self, new FResState
+            {
+                Layout = Layout,
+                Access = Access,
+                Stages = Stages,
+                Legacy = Legacy,
+                CrossQueue = CrossQueue ?? Resource.NativeState.CrossQueue,
+            }, ImageFlags
+        );
+        private void ReqState(
+            CommandList self, FResState NewState,
+            FImageBarrierFlags ImageFlags = FImageBarrierFlags.None
+        )
+        {
+            ref var OldState = ref Resource.NativeState;
+            if (First)
+            {
+                First = false;
+                OldState.Access = FResAccess.NoAccess;
+            }
+            if (OldState.IsCompatible(NewState, self.UseLegacyState, true, out var same))
+            {
+                if (same) goto Ret;
+                NewState = OldState.Merge(NewState, self.UseLegacyState, true);
+                if (CurrentBarrierIndex < 0) goto Add;
+                goto Merge;
+            }
+        Add:
+            {
+                CurrentBarrierIndex = self.m_barriers.Count;
+                if (self.m_current_barrier_cmd_index < 0 || LastUsedBarrierCmdIndex >= self.m_current_barrier_cmd_index)
+                {
+                    CurrentBarrierCmdIndex = self.m_current_barrier_cmd_index = self.m_commands.Count;
+                    var cmd = new FCommandBarrier
+                    {
+                        Base = { Type = FCommandType.Barrier },
+                        BarrierCount = 1,
+                        BarrierIndex = (uint)CurrentBarrierIndex,
+                    };
+                    self.m_commands.Add(new() { Barrier = cmd });
+                }
+                else
+                {
+                    CurrentBarrierCmdIndex = self.m_current_barrier_cmd_index;
+                    ref var cmd = ref self.m_commands.At(CurrentBarrierCmdIndex);
+                    cmd.Barrier.BarrierCount++;
+                }
+                self.m_barriers.Add(BuildBarrier(OldState, NewState));
+                goto End;
+            }
+        Merge:
+            {
+                ref var barrier = ref self.m_barriers.At(CurrentBarrierIndex);
+                UpdateBarrier(ref barrier, NewState);
+                goto End;
+            }
+        End:
+            OldState = NewState;
+        Ret:
+            MarkUse(self);
+            return;
+        }
+
+        private FBarrier BuildBarrier(
+            in FResState OldState, in FResState NewState,
+            FImageBarrierFlags ImageFlags = FImageBarrierFlags.None
+        )
+        {
+            var barrier = new FBarrier();
+            switch (Resource.Type)
+            {
+            case GpuResourceType.Unknown:
+                barrier.Type = FBarrierType.Global;
+                barrier.Global = new()
+                {
+                    AccessBefore = OldState.Access,
+                    AccessAfter = NewState.Access,
+                    StagesBefore = OldState.Stages,
+                    StagesAfter = NewState.Stages,
+                };
+                break;
+            case GpuResourceType.Buffer:
+                barrier.Type = FBarrierType.Buffer;
+                barrier.Buffer = new()
+                {
+                    LegacyBefore = OldState.Legacy,
+                    LegacyAfter = NewState.Legacy,
+                    AccessBefore = OldState.Access,
+                    AccessAfter = NewState.Access,
+                    StagesBefore = OldState.Stages,
+                    StagesAfter = NewState.Stages,
+                    Buffer = new(SlotIndex + 1),
+                    Offset = 0,
+                    Size = Resource.Size,
+                };
+                break;
+            case GpuResourceType.Image:
+                barrier.Type = FBarrierType.Image;
+                barrier.Image = new()
+                {
+                    LegacyBefore = OldState.Legacy,
+                    LegacyAfter = NewState.Legacy,
+                    AccessBefore = OldState.Access,
+                    AccessAfter = NewState.Access,
+                    StagesBefore = OldState.Stages,
+                    StagesAfter = NewState.Stages,
+                    LayoutBefore = OldState.Layout,
+                    LayoutAfter = NewState.Layout,
+                    Image = new(SlotIndex + 1),
+                    SubResourceRange = new()
+                    {
+                        IndexOrFirstMipLevel = 0,
+                        NumMipLevels = Resource.MipLevels,
+                        FirstArraySlice = 0,
+                        NumArraySlices = Resource.DepthOrLength,
+                        FirstPlane = 0,
+                        NumPlanes = Resource.Planes,
+                    },
+                    Flags = ImageFlags,
+                };
+                if (OldState.CrossQueue || NewState.CrossQueue)
+                {
+                    // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                    barrier.Image.Flags |= FImageBarrierFlags.CrossQueue;
+                }
+                break;
+            default:
+                throw new ArgumentOutOfRangeException();
+            }
+            return barrier;
+        }
+
+        private void UpdateBarrier(ref FBarrier barrier, in FResState NewState)
+        {
+            switch (Resource.Type)
+            {
+            case GpuResourceType.Unknown:
+                barrier.Global.AccessAfter = NewState.Access;
+                barrier.Global.StagesAfter = NewState.Stages;
+                break;
+            case GpuResourceType.Buffer:
+                barrier.Buffer.LegacyAfter = NewState.Legacy;
+                barrier.Buffer.AccessAfter = NewState.Access;
+                barrier.Buffer.StagesAfter = NewState.Stages;
+                break;
+            case GpuResourceType.Image:
+                barrier.Image.LegacyAfter = NewState.Legacy;
+                barrier.Image.AccessAfter = NewState.Access;
+                barrier.Image.StagesAfter = NewState.Stages;
+                // 状态兼容布局必须相同，这里不需要设置布局
+                break;
+            default:
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+
+    [Flags]
+    internal enum ScopedStateUsage
+    {
+        Common = 0,
+        Pixel = 1 << 0,
+        Vertex = 1 << 1,
+        Mesh = 1 << 2,
+        Compute = 1 << 3,
+    }
+
+    internal record struct ScopedState(
+        ScopedStateUsage Usage,
+        ResLayout Layout,
+        ResAccess Access,
+        LegacyState Legacy
+    )
+    {
+        public ScopedStateUsage Usage = Usage;
+        public ResLayout Layout = Layout;
+        public ResAccess Access = Access;
+        public LegacyState Legacy = Legacy;
+
+        public readonly bool IsCompatible(in ScopedState other, bool legacy, out bool same)
+        {
+            if (legacy)
+            {
+                same = Legacy == other.Legacy;
+                return Legacy.IsCompatible(other.Legacy);
+            }
+            if (Layout != other.Layout) goto no;
+            if (Access != other.Access)
+            {
+                same = false;
+                var sna = (Access & ResAccess.NoAccess) != 0;
+                var ona = (other.Access & ResAccess.NoAccess) != 0;
+                if (sna || ona) return true;
+                if (!Access.IsReadOnly() || !other.Access.IsReadOnly()) goto no;
+            }
+            else
+            {
+                same = true;
+            }
+            return true;
+        no:
+            same = false;
+            return false;
+        }
+
+        public void Merge(in ScopedState other, bool legacy, bool same)
+        {
+            Usage |= other.Usage;
+            if (!same)
+            {
+                if (legacy) Legacy |= other.Legacy;
+                else Access |= other.Access;
+            }
+        }
+    }
+
+    #endregion
+
     #region Fields
 
+    internal readonly GraphicsInstance m_instance;
     internal readonly GpuQueue m_queue;
     internal readonly List<FCommandItem> m_commands = new();
+    internal readonly List<FRenderCommandItem> m_render_commands = new();
+    internal readonly List<FComputeCommandItem> m_compute_commands = new();
     internal readonly List<FResourceMeta> m_resource_metas = new();
+    internal readonly List<ResourceState> m_resource_states = new();
+    internal readonly List<FRenderInfo> m_render_infos = new();
+    internal readonly List<FComputeInfo> m_compute_infos = new();
+    internal readonly List<FResolveInfo> m_resolve_infos = new();
+    internal readonly List<FRect> m_rects = new();
+    internal readonly List<FViewport> m_viewports = new();
+    internal readonly List<FMeshBuffers> m_mesh_buffers = new();
+    internal readonly List<FVertexBufferRange> m_vertex_buffer_ranges = new();
+    internal readonly List<FBufferCopyRange> m_buffer_copy_ranges = new();
+    internal readonly List<FBindItem> m_bind_items = new();
+    internal readonly List<FBarrier> m_barriers = new();
+    internal readonly List<byte> m_string8 = new();
+    internal readonly List<char> m_string16 = new();
     internal readonly Dictionary<object, int> m_resources = new();
+    internal readonly Dictionary<FResourceRef, ScopedState> m_scoped_res_state = new();
     internal readonly HashSet<object> m_objects = new();
-    internal readonly List<byte> m_payload = new();
     internal GpuOutput? m_current_output;
-    internal ShaderPipeline? m_current_pipeline;
+    internal int m_debug_scope_count;
+    internal int m_render_debug_scope_count;
+    internal int m_compute_debug_scope_count;
+    internal int m_current_barrier_cmd_index = -1;
+    internal bool m_in_render_or_compute_scope;
+    internal bool m_auto_barrier = true;
+    internal readonly bool m_use_legacy_state;
 
     #endregion
 
     #region Props
 
     public GpuQueue Queue => m_queue;
+    public bool DebugEnabled => m_instance.DebugEnabled;
+    public bool AutoBarrierEnabled => m_auto_barrier;
+    public bool UseLegacyState => m_use_legacy_state;
+
+    internal ref ResourceState StateAt(FResourceRef r) => ref m_resource_states.At((int)(r.ResourceIndex - 1));
 
     #endregion
 
     #region Ctor
 
-    internal CommandList(GpuQueue mQueue)
+    internal CommandList(GpuQueue queue)
     {
-        m_queue = mQueue;
+        m_queue = queue;
+        m_instance = queue.Device.Instance;
+        m_use_legacy_state = m_queue.m_device.m_adapter.UseLegacyState;
     }
 
     #endregion
@@ -53,18 +325,130 @@ internal CommandList(GpuQueue mQueue)
     internal void Reset()
     {
         m_commands.Clear();
+        m_render_commands.Clear();
+        m_compute_commands.Clear();
         m_resource_metas.Clear();
+        m_resource_states.Clear();
+        m_render_infos.Clear();
+        m_compute_infos.Clear();
+        m_resolve_infos.Clear();
+        m_rects.Clear();
+        m_viewports.Clear();
+        m_mesh_buffers.Clear();
+        m_vertex_buffer_ranges.Clear();
+        m_buffer_copy_ranges.Clear();
+        m_bind_items.Clear();
+        m_barriers.Clear();
+        m_string8.Clear();
+        m_string16.Clear();
         m_resources.Clear();
         m_objects.Clear();
-        m_payload.Clear();
+        m_current_barrier_cmd_index = -1;
+        m_auto_barrier = true;
         m_current_output = null;
     }
 
     #endregion
 
+    #region Submit
+
+    internal void BuildSubmitStruct(GpuExecutor Executor, bool NoWait)
+    {
+        if (m_debug_scope_count != 0)
+            throw new InvalidOperationException(
+                "There is still Debug scope not ended, please check whether Dispose is missed."
+            );
+        if (m_in_render_or_compute_scope)
+            throw new InvalidOperationException(
+                "There is still Render or Compute scope not ended, please check whether Dispose is missed."
+            );
+
+        fixed (FCommandItem* p_commands = CollectionsMarshal.AsSpan(m_commands))
+        fixed (FRenderCommandItem* p_render_commands = CollectionsMarshal.AsSpan(m_render_commands))
+        fixed (FComputeCommandItem* p_compute_commands = CollectionsMarshal.AsSpan(m_compute_commands))
+        fixed (FResourceMeta* p_resources = CollectionsMarshal.AsSpan(m_resource_metas))
+        fixed (FRenderInfo* p_render_infos = CollectionsMarshal.AsSpan(m_render_infos))
+        fixed (FComputeInfo* p_compute_infos = CollectionsMarshal.AsSpan(m_compute_infos))
+        fixed (FResolveInfo* p_resolve_infos = CollectionsMarshal.AsSpan(m_resolve_infos))
+        fixed (FRect* p_rects = CollectionsMarshal.AsSpan(m_rects))
+        fixed (FViewport* p_viewports = CollectionsMarshal.AsSpan(m_viewports))
+        fixed (FMeshBuffers* p_mesh_buffers = CollectionsMarshal.AsSpan(m_mesh_buffers))
+        fixed (FVertexBufferRange* p_vertex_buffer_ranges = CollectionsMarshal.AsSpan(m_vertex_buffer_ranges))
+        fixed (FBufferCopyRange* p_buffer_copy_ranges = CollectionsMarshal.AsSpan(m_buffer_copy_ranges))
+        fixed (FBindItem* p_bind_items = CollectionsMarshal.AsSpan(m_bind_items))
+        fixed (FBarrier* p_barriers = CollectionsMarshal.AsSpan(m_barriers))
+        fixed (byte* p_string8 = CollectionsMarshal.AsSpan(m_string8))
+        fixed (char* p_string16 = CollectionsMarshal.AsSpan(m_string16))
+        {
+            FCommandSubmit submit = new()
+            {
+                Commands = p_commands,
+                RenderCommands = p_render_commands,
+                ComputeCommands = p_compute_commands,
+                Resources = p_resources,
+                RenderInfos = p_render_infos,
+                ComputeInfos = p_compute_infos,
+                ResolveInfos = p_resolve_infos,
+                Rects = p_rects,
+                Viewports = p_viewports,
+                MeshBuffers = p_mesh_buffers,
+                VertexBufferRanges = p_vertex_buffer_ranges,
+                BufferCopyRanges = p_buffer_copy_ranges,
+                BindItems = p_bind_items,
+                Barriers = p_barriers,
+                Str8 = p_string8,
+                Str16 = p_string16,
+                CommandCount = (uint)m_commands.Count,
+                ResourceCount = (uint)m_resource_metas.Count,
+            };
+            Queue.ActualSubmit(Executor, &submit, NoWait);
+        }
+    }
+
+    #endregion
+
+    #region RecordScopedResState
+
+    internal ref ScopedState RecordScopedResState(FResourceRef res, ScopedState state, out bool compatible)
+    {
+        ref var slot = ref CollectionsMarshal.GetValueRefOrAddDefault(
+            m_scoped_res_state, res, out var exists
+        );
+        if (!exists)
+        {
+            slot = state;
+            compatible = true;
+            return ref slot;
+        }
+        if (slot.IsCompatible(state, UseLegacyState, out var same))
+        {
+            slot.Merge(state, UseLegacyState, same);
+            compatible = true;
+            return ref slot;
+        }
+        else
+        {
+            compatible = false;
+            return ref slot;
+        }
+    }
+
+    internal ArgumentException Incompatible(
+        string Name, in ScopedState old_state, LegacyState Legacy, ResAccess Access
+    ) =>
+        UseLegacyState
+            ? new ArgumentException(
+                $"{Name} cannot be in [{Legacy}] and [{old_state.Legacy}] states at the same time"
+            )
+            : new ArgumentException(
+                $"{Name} cannot be in [{Access}] and [{old_state.Access}] states at the same time"
+            );
+
+    #endregion
+
     #region AddResource
 
-    private int AddResource<T>(T resource) where T : IView
+    internal FResourceRef AddResource(IGpuResource resource)
     {
         if (resource.Queue != m_queue)
             throw new ArgumentException($"Resource {resource} does not belong to queue {m_queue}");
@@ -79,8 +463,9 @@ private int AddResource<T>(T resource) where T : IView
         {
             slot = m_resource_metas.Count;
             m_resource_metas.Add(resource.GetMeta());
+            m_resource_states.Add(new(slot, resource));
         }
-        return slot;
+        return new(slot + 1);
     }
 
     #endregion
@@ -96,24 +481,217 @@ private int AddResource<T>(T resource) where T : IView
 
     #region Commands
 
+    #region Debug
+
+    #region AddString
+
+    internal uint AddString(string str)
+    {
+        var index = m_string16.Count;
+        CollectionsMarshal.SetCount(m_string16, index + str.Length + 1);
+        var dst = CollectionsMarshal.AsSpan(m_string16).Slice(index, str.Length + 1);
+        str.CopyTo(dst);
+        dst[str.Length] = '\0';
+        return (uint)index;
+    }
+
+    internal uint AddString(ReadOnlySpan<byte> str)
+    {
+        var index = m_string8.Count;
+        CollectionsMarshal.SetCount(m_string8, index + str.Length + 1);
+        var dst = CollectionsMarshal.AsSpan(m_string8).Slice(index, str.Length + 1);
+        str.CopyTo(dst);
+        dst[str.Length] = 0;
+        return (uint)index;
+    }
+
+    #endregion
+
+    #region Label
+
+    public void Label(string Label)
+    {
+        if (!DebugEnabled) return;
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.Label },
+            StringIndex = AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+    }
+
+    public void Label(ReadOnlySpan<byte> Label)
+    {
+        if (!DebugEnabled) return;
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.Label },
+            StringIndex = AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str8,
+        };
+        m_commands.Add(new() { Label = cmd });
+    }
+
+    #endregion
+
+    #region Scope
+
+    public DebugScope Scope(string Name)
+    {
+        if (!DebugEnabled) return new(this);
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.BeginScope },
+            StringIndex = AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+        m_debug_scope_count++;
+        return new(this);
+    }
+
+    public DebugScope Scope(ReadOnlySpan<byte> Name)
+    {
+        if (!DebugEnabled) return new(this);
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.BeginScope },
+            StringIndex = AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str8,
+        };
+        m_commands.Add(new() { Label = cmd });
+        m_debug_scope_count++;
+        return new(this);
+    }
+
+    #endregion
+
+    #endregion
+
     #region Present
 
-    internal void Present(GpuOutput Output, CommandFlags Flags = CommandFlags.None)
+    internal void Present(GpuOutput Output)
     {
-        var index = AddResource(Output);
         var cmd = new FCommandPresent
         {
-            Image = new(index),
+            Base = { Type = FCommandType.Present },
+            Image = AddResource(Output),
         };
-        m_commands.Add(
-            new()
+        if (AutoBarrierEnabled)
+        {
+            ref var state = ref StateAt(cmd.Image);
+            state.ReqState(
+                this,
+                FResLayout.Present,
+                FResAccess.NoAccess,
+                FShaderStageFlags.None,
+                FLegacyState.Present,
+                true
+            );
+        }
+        m_commands.Add(new() { Present = cmd });
+    }
+
+    #endregion
+
+    #region Barrier
+
+    public void SetAutoBarrier(bool Enable) => m_auto_barrier = Enable;
+
+    public void Barrier(params ReadOnlySpan<Barrier> Barriers)
+    {
+        var index = m_barriers.Count;
+        CollectionsMarshal.SetCount(m_barriers, index + Barriers.Length);
+        var barriers = CollectionsMarshal.AsSpan(m_barriers).Slice(index, Barriers.Length);
+        for (var i = 0; i < Barriers.Length; i++)
+        {
+            ref readonly var src = ref Barriers[i];
+            ref var dst = ref barriers[i];
+            FBarrier item = default;
+            switch (src.Tag)
+            {
+            case Core.Barrier.Tags.None:
             {
-                Type = FCommandType.Present,
-                Flags = (FCommandFlags)Flags,
-                Present = cmd,
+                item.Type = FBarrierType.None;
+                break;
             }
-        );
-        Output.UnsafeChangeState(FResourceState.Present);
+            case Core.Barrier.Tags.Global:
+            {
+                item.Type = FBarrierType.Global;
+                var global = src.Global;
+                item.Global = new()
+                {
+                    AccessBefore = global.AccessBefore.ToFFI(),
+                    AccessAfter = global.AccessAfter.ToFFI(),
+                    StagesBefore = global.StagesBefore.ToFFI(),
+                    StagesAfter = global.StagesAfter.ToFFI(),
+                };
+                break;
+            }
+            case Core.Barrier.Tags.Buffer:
+            {
+                item.Type = FBarrierType.Buffer;
+                var buffer = src.Buffer;
+                item.Buffer = new()
+                {
+                    LegacyBefore = buffer.LegacyBefore.ToFFI(),
+                    LegacyAfter = buffer.LegacyAfter.ToFFI(),
+                    AccessBefore = buffer.AccessBefore.ToFFI(),
+                    AccessAfter = buffer.AccessAfter.ToFFI(),
+                    StagesBefore = buffer.StagesBefore.ToFFI(),
+                    StagesAfter = buffer.StagesAfter.ToFFI(),
+                    Buffer = AddResource(buffer.Buffer),
+                    Offset = buffer.Offset,
+                    Size = buffer.Size,
+                };
+                break;
+            }
+            case Core.Barrier.Tags.Image:
+            {
+                item.Type = FBarrierType.Image;
+                var image = src.Image;
+                item.Image = new()
+                {
+                    LegacyBefore = image.LegacyBefore.ToFFI(),
+                    LegacyAfter = image.LegacyAfter.ToFFI(),
+                    AccessBefore = image.AccessBefore.ToFFI(),
+                    AccessAfter = image.AccessAfter.ToFFI(),
+                    StagesBefore = image.StagesBefore.ToFFI(),
+                    StagesAfter = image.StagesAfter.ToFFI(),
+                    LayoutBefore = image.LayoutBefore.ToFFI(),
+                    LayoutAfter = image.LayoutAfter.ToFFI(),
+                    Image = AddResource(image.Image),
+                    SubResourceRange = new()
+                    {
+                        IndexOrFirstMipLevel = image.SubResourceRange.IndexOrFirstMipLevel,
+                        NumMipLevels = image.SubResourceRange.NumMipLevels,
+                        FirstArraySlice = image.SubResourceRange.FirstArraySlice,
+                        NumArraySlices = image.SubResourceRange.NumArraySlices,
+                        FirstPlane = image.SubResourceRange.FirstPlane,
+                        NumPlanes = image.SubResourceRange.NumPlanes,
+                    },
+                    Flags = (FImageBarrierFlags)image.Flags,
+                };
+                break;
+            }
+            default:
+                throw new ArgumentOutOfRangeException();
+            }
+            dst = item;
+        }
+        var cmd = new FCommandBarrier
+        {
+            Base = { Type = FCommandType.Barrier },
+            BarrierCount = (uint)Barriers.Length,
+            BarrierIndex = (uint)index,
+        };
+        m_current_barrier_cmd_index = m_commands.Count;
+        m_commands.Add(new() { Barrier = cmd });
     }
 
     #endregion
@@ -123,46 +701,40 @@ internal void Present(GpuOutput Output, CommandFlags Flags = CommandFlags.None)
     /// <summary>
     /// 使用 (0, 0, 0, 1) 清空 Rtv
     /// </summary>
-    public void ClearColor<Rtv>(
-        Rtv Image, ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Rtv : IRtv => ClearColor(Image, new(0, 0, 0, 1), Rects, Flags);
+    public void ClearColor(IRtv Image, ReadOnlySpan<URect> Rects = default) =>
+        ClearColor(Image, new(0, 0, 0, 1), Rects);
 
     /// <summary>
     /// 使用指定的颜色清空 Rtv
     /// </summary>
-    public void ClearColor<Rtv>(
-        Rtv Image, float4 Color, ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Rtv : IRtv
+    public void ClearColor(IRtv Image, float4 Color, ReadOnlySpan<URect> Rects = default)
     {
         if (!Image.TryRtv()) throw new ArgumentException($"Resource {Image} cannot be used as Rtv");
 
-        var index = AddResource(Image);
-
         var cmd = new FCommandClearColor
         {
+            Base = { Type = FCommandType.ClearColor },
             RectCount = (uint)Rects.Length,
-            Image = new(index),
+            Image = AddResource(Image.Resource),
+            Color = Unsafe.BitCast<float4, FCommandClearColor._Color_e__FixedBuffer>(Color),
         };
-        cmd.Color[0] = Color.r;
-        cmd.Color[1] = Color.g;
-        cmd.Color[2] = Color.b;
-        cmd.Color[3] = Color.a;
         if (Rects.Length > 0)
         {
-            cmd.RectIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(Rects));
+            cmd.RectIndex = (uint)m_rects.Count;
+            m_rects.AddRange(MemoryMarshal.Cast<URect, FRect>(Rects));
         }
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.ClearColor,
-                Flags = (FCommandFlags)Flags,
-                ClearColor = cmd,
-            }
-        );
-        Image.UnsafeChangeState(FResourceState.RenderTarget);
+        if (AutoBarrierEnabled)
+        {
+            ref var state = ref StateAt(cmd.Image);
+            state.ReqState(
+                this,
+                FResLayout.RenderTarget,
+                FResAccess.RenderTarget,
+                FShaderStageFlags.None,
+                FLegacyState.RenderTarget
+            );
+        }
+        m_commands.Add(new() { ClearColor = cmd });
     }
 
     #endregion
@@ -172,269 +744,986 @@ public void ClearColor<Rtv>(
     /// <summary>
     /// 使用指定的 1 深度 和 0 模板 清空 Dsv
     /// </summary>
-    public void ClearDepthStencil<Dsv>(
-        Dsv Image,
-        ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Dsv : IDsv => ClearDepthStencil(Image, 1, 0, DsvClear.All, Rects, Flags);
+    public void ClearDepthStencil(
+        IDsv Image,
+        ReadOnlySpan<URect> Rects = default
+    ) => ClearDepthStencil(Image, 1, 0, DsvClear.All, Rects);
 
     /// <summary>
     /// 使用指定的深度清空 Dsv
     /// </summary>
-    public void ClearDepthStencil<Dsv>(
-        Dsv Image, float Depth,
-        ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Dsv : IDsv => ClearDepthStencil(Image, Depth, 0, DsvClear.Depth, Rects, Flags);
+    public void ClearDepthStencil(
+        IDsv Image, float Depth,
+        ReadOnlySpan<URect> Rects = default
+    ) => ClearDepthStencil(Image, Depth, 0, DsvClear.Depth, Rects);
 
     /// <summary>
     /// 使用指定的模板清空 Dsv
     /// </summary>
-    public void ClearDepthStencil<Dsv>(
-        Dsv Image, byte Stencil,
-        ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Dsv : IDsv => ClearDepthStencil(Image, 1, Stencil, DsvClear.Stencil, Rects, Flags);
+    public void ClearDepthStencil(
+        IDsv Image, byte Stencil,
+        ReadOnlySpan<URect> Rects = default
+    ) => ClearDepthStencil(Image, 1, Stencil, DsvClear.Stencil, Rects);
 
     /// <summary>
     /// 使用指定的深度和模板清空 Dsv
     /// </summary>
-    public void ClearDepthStencil<Dsv>(
-        Dsv Image, float Depth, byte Stencil, DsvClear Clear = DsvClear.All,
-        ReadOnlySpan<URect> Rects = default,
-        CommandFlags Flags = CommandFlags.None
-    ) where Dsv : IDsv
+    public void ClearDepthStencil(
+        IDsv Image, float Depth, byte Stencil, DsvClear Clear = DsvClear.All,
+        ReadOnlySpan<URect> Rects = default
+    )
     {
         if (!Image.TryDsv()) throw new ArgumentException($"Resource {Image} cannot be used as Dsv");
 
-        var index = AddResource(Image);
-
         var cmd = new FCommandClearDepthStencil
         {
+            Base = { Type = FCommandType.ClearDepthStencil },
             RectCount = (uint)Rects.Length,
-            Image = new(index),
+            Image = AddResource(Image.Resource),
             Depth = Depth,
             Stencil = Stencil,
             Clear = (FDepthStencilClearFlags)Clear,
         };
         if (Rects.Length > 0)
         {
-            cmd.RectIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(Rects));
+            cmd.RectIndex = (uint)m_rects.Count;
+            m_rects.AddRange(MemoryMarshal.Cast<URect, FRect>(Rects));
         }
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.ClearDepthStencil,
-                Flags = (FCommandFlags)Flags,
-                ClearDepthStencil = cmd,
-            }
-        );
-        Image.UnsafeChangeState(FResourceState.DepthWrite);
+        if (AutoBarrierEnabled)
+        {
+            ref var state = ref StateAt(cmd.Image);
+            state.ReqState(
+                this,
+                FResLayout.DepthStencilWrite,
+                FResAccess.DepthStencilWrite,
+                FShaderStageFlags.None,
+                FLegacyState.DepthWrite
+            );
+        }
+        m_commands.Add(new() { ClearDepthStencil = cmd });
     }
 
     #endregion
 
-    #region SetRenderTargets
+    #region Bind
 
-    public void SetRenderTargets(
-        ReadOnlySpan<IRtv> Rtvs, IDsv? Dsv = null,
-        bool AutoViewportScissor = true,
-        CommandFlags Flags = CommandFlags.None
+    public void Bind(
+        ShaderBinding Binding, ReadOnlySpan<ShaderBindingSetItem> Items
     )
     {
-        if (Rtvs.Length == 0 && Dsv == null) throw new ArgumentException("No Rtvs or Dsv");
-        var num_rtv = Math.Min(Rtvs.Length, 8);
-        for (var i = 0; i < num_rtv; i++)
-        {
-            var rtv = Rtvs[i];
-            if (!rtv.TryRtv()) throw new ArgumentException($"Resource {rtv} cannot be used as Rtv");
-        }
-        if (Dsv != null && !Dsv.TryDsv()) throw new ArgumentException($"Resource {Dsv} cannot be used as Dsv");
-
-        var cmd = new FCommandSetRenderTargets
+        AddObject(Binding);
+        var cmd = new FCommandBind
         {
-            Dsv = Dsv == null ? new(uint.MaxValue) : new(AddResource(Dsv)),
-            NumRtv = (uint)num_rtv,
+            Base = { Type = FCommandType.Bind },
+            Binding = Binding.m_ptr,
+            ItemCount = (uint)Items.Length,
+            ItemsIndex = 0
         };
-        var rt_size = Dsv?.Size ?? Rtvs[0].Size;
-        for (var i = 0; i < num_rtv; i++)
-        {
-            cmd.Rtv[i] = new(AddResource(Rtvs[i]));
-            if (!Rtvs[i].Size.Equals(rt_size))
-                throw new ArgumentException($"RenderTargets And DepthStencil must be the same size");
-        }
-        if (AutoViewportScissor)
+        if (Items.Length > 0)
         {
-            cmd.ViewportCount = 1;
-            cmd.ScissorRectCount = 1;
-            var viewport = new UViewPort
-            {
-                Width = rt_size.x,
-                Height = rt_size.y,
-            };
-            var scissor = new URect
-            {
-                Right = rt_size.x,
-                Bottom = rt_size.y,
-            };
-            cmd.ViewportIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(new ReadOnlySpan<UViewPort>(in viewport)));
-            cmd.ScissorRectIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(new ReadOnlySpan<URect>(in scissor)));
-        }
-        m_commands.Add(
-            new()
+            var index = m_bind_items.Count;
+            cmd.ItemsIndex = (uint)index;
+            CollectionsMarshal.SetCount(m_bind_items, m_bind_items.Count + Items.Length);
+            var dst = CollectionsMarshal.AsSpan(m_bind_items).Slice(index, Items.Length);
+            var defines = Binding.Layout.NativeDefines;
+            var views = Binding.MutViews;
+            for (var i = 0; i < Items.Length; i++)
             {
-                Type = FCommandType.SetRenderTargets,
-                Flags = (FCommandFlags)Flags,
-                SetRenderTargets = cmd,
+                var src = Items[i];
+                ref readonly var define = ref defines[(int)src.Index];
+                define.CheckCompatible(src.View, (int)src.Index);
+                dst[i] = new()
+                {
+                    Index = src.Index,
+                    View = src.View.ToFFI(),
+                };
+                views[(int)src.Index] = src.View;
             }
-        );
-        for (var i = 0; i < num_rtv; i++)
-        {
-            Rtvs[i].UnsafeChangeState(FResourceState.RenderTarget);
         }
-        Dsv?.UnsafeChangeState(FResourceState.DepthWrite);
+        m_commands.Add(new() { Bind = cmd });
     }
 
     #endregion
 
-    #region SetViewportScissor
+    #region BufferCopy
 
-    public void SetViewportScissor(
-        ReadOnlySpan<UViewPort> Viewports,
-        ReadOnlySpan<URect> Scissors,
-        CommandFlags Flags = CommandFlags.None
+    public void Copy(
+        GpuBuffer Dst,
+        GpuBuffer Src,
+        ulong DstOffset = 0,
+        ulong SrcOffset = 0,
+        ulong Size = ulong.MaxValue
     )
     {
-        var cmd = new FCommandSetViewportScissor
-        {
-            ViewportCount = (uint)Viewports.Length,
-            ScissorRectCount = (uint)Scissors.Length,
-        };
-        if (Viewports.Length > 0)
+        if (Size != ulong.MaxValue)
         {
-            cmd.ViewportIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(Viewports));
+            if (DstOffset + Size > Dst.Size) throw new ArgumentException("The copy range exceeds the buffer range");
+            if (SrcOffset + Size > Src.Size) throw new ArgumentException("The copy range exceeds the buffer range");
         }
-        if (Scissors.Length > 0)
+        else if (Dst == Src || Dst.Size != Src.Size) Size = Math.Min(Dst.Size, Src.Size);
+        var cmd = new FCommandBufferCopy
         {
-            cmd.ScissorRectIndex = (uint)m_payload.Count;
-            m_payload.AddRange(MemoryMarshal.AsBytes(Scissors));
-        }
-        m_commands.Add(
+            Base = { Type = FCommandType.BufferCopy },
+            RangeIndex = (uint)m_buffer_copy_ranges.Count,
+            Dst = { Buffer = AddResource(Dst) },
+            DstType = FBufferRefType.Buffer,
+            Src = { Buffer = AddResource(Src) },
+            SrcType = FBufferRefType.Buffer,
+        };
+        m_buffer_copy_ranges.Add(
             new()
             {
-                Type = FCommandType.SetViewportScissor,
-                Flags = (FCommandFlags)Flags,
-                SetViewportScissor = cmd,
+                Size = Size,
+                DstOffset = DstOffset,
+                SrcOffset = SrcOffset,
             }
         );
+        if (AutoBarrierEnabled)
+        {
+            {
+                ref var state = ref StateAt(cmd.Src.Buffer);
+                state.ReqState(
+                    this,
+                    FResLayout.None,
+                    FResAccess.CopySrc,
+                    FShaderStageFlags.None,
+                    FLegacyState.CopySrc
+                );
+            }
+            {
+                ref var state = ref StateAt(cmd.Dst.Buffer);
+                state.ReqState(
+                    this,
+                    FResLayout.None,
+                    FResAccess.CopyDst,
+                    FShaderStageFlags.None,
+                    FLegacyState.CopyDst
+                );
+            }
+        }
+        m_commands.Add(new() { BufferCopy = cmd });
     }
 
     #endregion
 
-    #region SetPipeline
+    #region BufferUpload
 
-    public void SetPipeline(ShaderPipeline Pipeline, CommandFlags Flags = CommandFlags.None)
+    public void Upload<T>(
+        GpuBuffer Dst,
+        ReadOnlySpan<T> Data,
+        ulong DstOffset = 0
+    ) where T : unmanaged => Upload(Dst, MemoryMarshal.AsBytes(Data), DstOffset);
+
+    public void Upload(
+        GpuBuffer Dst,
+        ReadOnlySpan<byte> Data,
+        ulong DstOffset = 0
+    )
     {
-        AddObject(m_current_pipeline = Pipeline);
-        var cmd = new FCommandSetPipeline
+        if (Data.Length == 0) return;
+        var Size = Math.Min(Dst.Size, (uint)Data.Length);
+        var src = m_queue.WriteToUpload(Data);
+        var cmd = new FCommandBufferCopy
         {
-            Pipeline = Pipeline.m_ptr,
+            Base = { Type = FCommandType.BufferCopy },
+            RangeIndex = (uint)m_buffer_copy_ranges.Count,
+            Dst = { Buffer = AddResource(Dst) },
+            DstType = FBufferRefType.Buffer,
+            Src = { Upload = src },
+            SrcType = FBufferRefType.Upload,
         };
-        m_commands.Add(
+        m_buffer_copy_ranges.Add(
             new()
             {
-                Type = FCommandType.SetPipeline,
-                Flags = (FCommandFlags)Flags,
-                SetPipeline = cmd,
+                Size = Size,
+                DstOffset = DstOffset,
+                SrcOffset = src.Offset,
             }
         );
+        if (AutoBarrierEnabled)
+        {
+            ref var state = ref StateAt(cmd.Dst.Buffer);
+            state.ReqState(
+                this,
+                FResLayout.None,
+                FResAccess.CopyDst,
+                FShaderStageFlags.None,
+                FLegacyState.CopyDst
+            );
+        }
+        m_commands.Add(new() { BufferCopy = cmd });
     }
 
-    #endregion
-
-    #region SetMeshBuffers
-
-    public void SetMeshBuffers(
-        MeshLayout MeshLayout,
+    public void Upload(
+        GpuBuffer Dst,
+        UploadLoc Loc,
+        ulong DstOffset = 0
+    )
+    {
+        if (Loc.SubmitId != m_queue.SubmitId)
+            throw new ArgumentException("An attempt was made to use an expired upload location");
+        var Size = Math.Min(Dst.Size, Loc.Size);
+        var cmd = new FCommandBufferCopy
+        {
+            Base = { Type = FCommandType.BufferCopy },
+            RangeIndex = (uint)m_buffer_copy_ranges.Count,
+            Dst = { Buffer = AddResource(Dst) },
+            DstType = FBufferRefType.Buffer,
+            Src = { Upload = Loc },
+            SrcType = FBufferRefType.Upload,
+        };
+        m_buffer_copy_ranges.Add(
+            new()
+            {
+                Size = Size,
+                DstOffset = DstOffset,
+                SrcOffset = Loc.Offset,
+            }
+        );
+        if (AutoBarrierEnabled)
+        {
+            ref var state = ref StateAt(cmd.Dst.Buffer);
+            state.ReqState(
+                this,
+                FResLayout.None,
+                FResAccess.CopyDst,
+                FShaderStageFlags.None,
+                FLegacyState.CopyDst
+            );
+        }
+        m_commands.Add(new() { BufferCopy = cmd });
+    }
+
+    #endregion
+
+    #region Render
+
+    public RenderScope Render(
+        ReadOnlySpan<RenderInfo.RtvInfo> Rtvs, RenderInfo.DsvInfo? Dsv = null,
+        bool AutoViewportScissor = true,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    ) => Render(new(Rtvs, Dsv), AutoViewportScissor, Name, Name8);
+    public RenderScope Render(
+        RenderInfo.DsvInfo Dsv, ReadOnlySpan<RenderInfo.RtvInfo> Rtvs = default,
+        bool AutoViewportScissor = true,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    ) => Render(new(Rtvs, Dsv), AutoViewportScissor, Name, Name8);
+    public RenderScope Render(
+        in RenderInfo Info,
+        bool AutoViewportScissor = true,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    )
+    {
+        #region Check Nested
+
+        if (m_in_render_or_compute_scope) throw new InvalidOperationException("Cannot nest Render or Compute scopes");
+        m_in_render_or_compute_scope = true;
+
+        #endregion
+
+        #region Check Args
+
+        if (Info.Dsv == null && Info.Rtvs.Length == 0) throw new ArgumentException("No any rtv or dsv provided");
+        if (Info.Rtvs.Length > 8) throw new ArgumentException("Too many rtvs provided, it can't be more than 8");
+
+        #endregion
+
+        #region Cmd
+
+        var info_index = m_render_infos.Count;
+        var cmd = new FCommandRender
+        {
+            Base = { Type = FCommandType.Render },
+            InfoIndex = (uint)info_index,
+            CommandStartIndex = (uint)m_render_commands.Count,
+        };
+
+        #endregion
+
+        #region Init
+
+        var has_dsv = Info.Dsv.HasValue;
+        var dsv = Info.Dsv ?? default;
+
+        #endregion
+
+        #region Info
+
+        FRenderInfo info = new()
+        {
+            Dsv = has_dsv ? AddResource(dsv.View!.Resource) : default,
+            NumRtv = (uint)Info.Rtvs.Length,
+            Depth = has_dsv && dsv.DepthLoad is { IsClear: true, Clear: var cd } ? cd : 1,
+            Stencil = has_dsv && dsv.StencilLoad is { IsClear: true, Clear: var cs } ? (byte)cs : (byte)0,
+        };
+
+        #endregion
+
+        #region DsvLoadOp
+
+        info.DsvLoadOp[0] = has_dsv
+            ? dsv.DepthLoad.Tag switch
+            {
+                LoadOp<float>.Tags.Load     => FLoadOp.Load,
+                LoadOp<float>.Tags.Clear    => FLoadOp.Clear,
+                LoadOp<float>.Tags.Discard  => FLoadOp.Discard,
+                LoadOp<float>.Tags.NoAccess => FLoadOp.NoAccess,
+                _                           => throw new ArgumentOutOfRangeException()
+            }
+            : FLoadOp.NoAccess;
+        info.DsvLoadOp[1] = has_dsv
+            ? dsv.StencilLoad.Tag switch
+            {
+                LoadOp<uint>.Tags.Load     => FLoadOp.Load,
+                LoadOp<uint>.Tags.Clear    => FLoadOp.Clear,
+                LoadOp<uint>.Tags.Discard  => FLoadOp.Discard,
+                LoadOp<uint>.Tags.NoAccess => FLoadOp.NoAccess,
+                _                          => throw new ArgumentOutOfRangeException()
+            }
+            : FLoadOp.NoAccess;
+
+        #endregion
+
+        #region DsvStoreOp
+
+        info.DsvStoreOp[0] = has_dsv
+            ? dsv.DepthStore.Tag switch
+            {
+                StoreOp.Tags.Store    => FStoreOp.Store,
+                StoreOp.Tags.Discard  => FStoreOp.Discard,
+                StoreOp.Tags.NoAccess => FStoreOp.NoAccess,
+                _                     => throw new ArgumentOutOfRangeException()
+            }
+            : FStoreOp.NoAccess;
+
+        info.DsvStoreOp[1] = has_dsv
+            ? dsv.StencilStore.Tag switch
+            {
+                StoreOp.Tags.Store    => FStoreOp.Store,
+                StoreOp.Tags.Discard  => FStoreOp.Discard,
+                StoreOp.Tags.NoAccess => FStoreOp.NoAccess,
+                _                     => throw new ArgumentOutOfRangeException()
+            }
+            : FStoreOp.NoAccess;
+
+        #endregion
+
+        #region Rtv
+
+        var rt_size = Info.Dsv?.View.Size2d ?? Info.Rtvs[0].View.Size2d;
+        for (var i = 0; i < Info.Rtvs.Length; i++)
+        {
+            ref readonly var rtv = ref Info.Rtvs[i];
+            if (!rtv.View.Size2d.Equals(rt_size))
+                throw new ArgumentException("RenderTargets And DepthStencil must be the same size");
+            info.Rtv[i] = AddResource(rtv.View.Resource);
+            info.ResolveInfoIndex[i] = uint.MaxValue; // todo
+            if (rtv.Load is { IsClear: true, Clear: var cc })
+                Unsafe.As<float, float4>(ref info.Color[i * 4]) = cc;
+            info.RtvLoadOp[i] = rtv.Load.Tag switch
+            {
+                LoadOp<float4>.Tags.Load     => FLoadOp.Load,
+                LoadOp<float4>.Tags.Clear    => FLoadOp.Clear,
+                LoadOp<float4>.Tags.Discard  => FLoadOp.Discard,
+                LoadOp<float4>.Tags.NoAccess => FLoadOp.NoAccess,
+                _                            => throw new ArgumentOutOfRangeException()
+            };
+            info.RtvStoreOp[i] = rtv.Store.Tag switch
+            {
+                StoreOp.Tags.Store    => FStoreOp.Store,
+                StoreOp.Tags.Discard  => FStoreOp.Discard,
+                StoreOp.Tags.NoAccess => FStoreOp.NoAccess,
+                _                     => throw new ArgumentOutOfRangeException()
+            };
+        }
+
+        #endregion
+
+        #region EndInfo
+
+        m_render_infos.Add(info);
+
+        #endregion
+
+        #region DebugScope
+
+        var debug_scope = false;
+        if (Name != null)
+        {
+            debug_scope = true;
+            Scope(Name);
+        }
+        else if (Name8.Length > 0)
+        {
+            debug_scope = true;
+            Scope(Name8);
+        }
+
+        #endregion
+
+        #region State
+
+        if (has_dsv)
+        {
+            ref var old_state = ref RecordScopedResState(
+                info.Dsv, new(
+                    ScopedStateUsage.Pixel,
+                    ResLayout.DepthStencilWrite,
+                    ResAccess.DepthStencilWrite,
+                    LegacyState.DepthWrite
+                ), out var compatible
+            );
+            if (!compatible)
+                throw Incompatible("Depth Stencil", old_state, LegacyState.DepthWrite, ResAccess.DepthStencilWrite);
+        }
+        for (var i = 0; i < info.NumRtv; i++)
+        {
+            ref var old_state = ref RecordScopedResState(
+                info.Rtv[i], new(
+                    ScopedStateUsage.Pixel,
+                    ResLayout.RenderTarget,
+                    ResAccess.RenderTarget,
+                    LegacyState.RenderTarget
+                ), out var compatible
+            );
+            if (!compatible)
+                throw Incompatible("Render Target", old_state, LegacyState.RenderTarget, ResAccess.RenderTarget);
+        }
+
+        #endregion
+
+        #region Scope
+
+        RenderScope scope = new(this, info_index, cmd, m_render_commands, debug_scope);
+
+        #endregion
+
+        #region AutoViewportScissor
+
+        if (AutoViewportScissor)
+        {
+            scope.SetViewportScissor(
+                [new UViewPort { Width = rt_size.x, Height = rt_size.y }],
+                [new URect { Right = rt_size.x, Bottom = rt_size.y }]
+            );
+        }
+
+        #endregion
+
+        return scope;
+    }
+
+    #endregion
+
+    #region Compute
+
+    public ComputeScope Compute(string? Name = null, ReadOnlySpan<byte> Name8 = default)
+    {
+        #region Check Nested
+
+        if (m_in_render_or_compute_scope) throw new InvalidOperationException("Cannot nest Render or Compute scopes");
+        m_in_render_or_compute_scope = true;
+
+        #endregion
+
+        #region Debug
+
+        var debug_scope = false;
+        if (Name != null)
+        {
+            debug_scope = true;
+            Scope(Name);
+        }
+        else if (Name8.Length > 0)
+        {
+            debug_scope = true;
+            Scope(Name8);
+        }
+
+        #endregion
+
+        #region Cmd and Scope
+
+        var info_index = m_compute_infos.Count;
+        m_compute_infos.Add(new());
+
+        var cmd = new FCommandCompute
+        {
+            Base = { Type = FCommandType.Compute },
+            InfoIndex = (uint)info_index,
+            CommandStartIndex = (uint)m_compute_commands.Count,
+        };
+        return new(this, info_index, cmd, m_compute_commands, debug_scope);
+
+        #endregion
+    }
+
+    #endregion
+
+    #endregion
+}
+
+#region DebugScope
+
+public struct DebugScope(CommandList self) : IDisposable
+{
+    private bool m_disposed;
+    public void Dispose()
+    {
+        if (m_disposed) throw new ObjectDisposedException(nameof(ComputeScope));
+        m_disposed = true;
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandEndScope
+        {
+            Base = { Type = FCommandType.EndScope },
+        };
+        self.m_commands.Add(new() { EndScope = cmd });
+        self.m_debug_scope_count--;
+    }
+}
+
+public struct RenderDebugScope(CommandList self) : IDisposable
+{
+    private bool m_disposed;
+    public void Dispose()
+    {
+        if (m_disposed) throw new ObjectDisposedException(nameof(ComputeScope));
+        m_disposed = true;
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandEndScope
+        {
+            Base = { Type = FCommandType.EndScope },
+        };
+        self.m_render_commands.Add(new() { EndScope = cmd });
+        self.m_render_debug_scope_count--;
+    }
+}
+
+public struct ComputeDebugScope(CommandList self) : IDisposable
+{
+    private bool m_disposed;
+    public void Dispose()
+    {
+        if (m_disposed) throw new ObjectDisposedException(nameof(ComputeScope));
+        m_disposed = true;
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandEndScope
+        {
+            Base = { Type = FCommandType.EndScope },
+        };
+        self.m_compute_commands.Add(new() { EndScope = cmd });
+        self.m_compute_debug_scope_count--;
+    }
+}
+
+#endregion
+
+#region RenderInfo
+
+[Union]
+public partial struct LoadOp
+{
+    [UnionTemplate]
+    private interface Template
+    {
+        void Load();
+        void Discard();
+        void NoAccess();
+    }
+
+    public static readonly LoadOp Load = MakeLoad();
+    public static LoadOp<T> Clear<T>(T Clear) => LoadOp<T>.MakeClear(Clear);
+    public static readonly LoadOp Discard = MakeDiscard();
+    public static readonly LoadOp NoAccess = MakeNoAccess();
+}
+
+[Union]
+public partial struct LoadOp<T>
+{
+    [UnionTemplate]
+    private interface Template
+    {
+        void Load();
+        T Clear();
+        void Discard();
+        void NoAccess();
+    }
+
+    public static readonly LoadOp<T> Load = MakeLoad();
+    public static implicit operator LoadOp<T>(T Clear) => MakeClear(Clear);
+    public static readonly LoadOp<T> Discard = MakeDiscard();
+    public static readonly LoadOp<T> NoAccess = MakeNoAccess();
+
+    public static implicit operator LoadOp<T>(LoadOp op) => op.Tag switch
+    {
+        LoadOp.Tags.Load     => Load,
+        LoadOp.Tags.Discard  => Discard,
+        LoadOp.Tags.NoAccess => NoAccess,
+        _                    => throw new ArgumentOutOfRangeException()
+    };
+}
+
+[Union]
+public partial struct StoreOp
+{
+    [UnionTemplate]
+    private interface Template
+    {
+        void Store();
+        void Discard();
+        void NoAccess();
+    }
+
+    public static readonly StoreOp Store = MakeStore();
+    public static readonly StoreOp Discard = MakeDiscard();
+    public static readonly StoreOp NoAccess = MakeNoAccess();
+}
+
+public ref struct RenderInfo(ReadOnlySpan<RenderInfo.RtvInfo> Rtvs, RenderInfo.DsvInfo? Dsv = null)
+{
+    public DsvInfo? Dsv = Dsv;
+    public ReadOnlySpan<RtvInfo> Rtvs = Rtvs;
+
+    public RenderInfo() : this([]) { }
+    public RenderInfo(DsvInfo Dsv, ReadOnlySpan<RtvInfo> Rtvs = default) : this(Rtvs, Dsv) { }
+
+    public struct DsvInfo(
+        IDsv View,
+        LoadOp<float> DepthLoad,
+        LoadOp<uint> StencilLoad,
+        StoreOp DepthStore,
+        StoreOp StencilStore
+    )
+    {
+        public IDsv View = View;
+        public LoadOp<float> DepthLoad = DepthLoad;
+        public LoadOp<uint> StencilLoad = StencilLoad;
+        public StoreOp DepthStore = DepthStore;
+        public StoreOp StencilStore = StencilStore;
+
+        public DsvInfo(IDsv View) : this(View, LoadOp.Load, LoadOp.Load, StoreOp.Store, StoreOp.Store) { }
+        public DsvInfo(IDsv View, LoadOp<float> DepthLoad, LoadOp<uint> StencilLoad)
+            : this(View, DepthLoad, StencilLoad, StoreOp.Store, StoreOp.Store) { }
+        public DsvInfo(IDsv View, LoadOp<float> DepthLoad)
+            : this(View, DepthLoad, LoadOp.Load, StoreOp.Store, StoreOp.Store) { }
+    }
+
+    public struct RtvInfo(IRtv View, LoadOp<float4> Load, StoreOp Store)
+    {
+        public IRtv View = View;
+        public LoadOp<float4> Load = Load;
+        public StoreOp Store = Store;
+
+        public RtvInfo(IRtv View) : this(View, LoadOp.Load, StoreOp.Store) { }
+
+        public RtvInfo(IRtv View, LoadOp<float4> Load) : this(View, Load, StoreOp.Store) { }
+    }
+}
+
+#endregion
+
+#region RenderScope
+
+public unsafe struct RenderScope(
+    CommandList self,
+    int info_index,
+    FCommandRender render_cmd,
+    List<FRenderCommandItem> m_commands,
+    bool debug_scope
+) : IDisposable
+{
+    #region Fields
+
+    internal FCommandRender render_cmd = render_cmd;
+    internal ShaderPipeline? m_current_pipeline;
+    internal ShaderBinding? m_current_binding;
+    internal bool m_disposed;
+    internal bool m_has_pixel_shader;
+    internal bool m_has_vertex_shader;
+    internal bool m_has_mesh_shader;
+    internal bool m_has_task_shader;
+    internal bool m_has_uav_writes;
+
+    #endregion
+
+    #region Props
+
+    internal ref FRenderInfo Info => ref CollectionsMarshal.AsSpan(self.m_render_infos)[info_index];
+
+    #endregion
+
+    #region Dispose
+
+    public void Dispose()
+    {
+        if (m_disposed) throw new ObjectDisposedException(nameof(ComputeScope));
+        m_disposed = true;
+        if (self.m_render_debug_scope_count != 0)
+            throw new InvalidOperationException(
+                "There is still Debug scope not ended, please check whether Dispose is missed."
+            );
+        ref var info = ref Info;
+        info.HasUavWrites = m_has_uav_writes;
+        if (self.AutoBarrierEnabled)
+        {
+            foreach (var (res, scoped_state) in self.m_scoped_res_state)
+            {
+                ref var state = ref self.StateAt(res);
+                var stages = ShaderStageFlags.None;
+                if (m_has_pixel_shader && (scoped_state.Usage & ScopedStateUsage.Pixel) != 0)
+                    stages |= ShaderStageFlags.Pixel;
+                if (m_has_vertex_shader && (scoped_state.Usage & ScopedStateUsage.Vertex) != 0)
+                    stages |= ShaderStageFlags.Vertex;
+                if (m_has_mesh_shader && (scoped_state.Usage & ScopedStateUsage.Mesh) != 0)
+                    stages |= ShaderStageFlags.Mesh;
+                if (m_has_task_shader && (scoped_state.Usage & ScopedStateUsage.Mesh) != 0)
+                    stages |= ShaderStageFlags.Task;
+                state.ReqState(
+                    self,
+                    scoped_state.Layout.ToFFI(),
+                    scoped_state.Access.ToFFI(),
+                    stages.ToFFI(),
+                    scoped_state.Legacy.ToFFI()
+                );
+            }
+            foreach (var res in self.m_scoped_res_state.Keys)
+            {
+                ref var state = ref self.StateAt(res);
+                state.MarkUse(self);
+            }
+        }
+        render_cmd.CommandCount = (uint)m_commands.Count - render_cmd.CommandStartIndex;
+        self.m_commands.Add(new() { Render = render_cmd });
+        self.m_in_render_or_compute_scope = false;
+        if (debug_scope) new DebugScope(self).Dispose();
+        self.m_scoped_res_state.Clear();
+    }
+
+    #endregion
+
+    #region Debug
+
+    #region Label
+
+    public void Label(string Label)
+    {
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.Label },
+            StringIndex = self.AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+    }
+
+    public void Label(ReadOnlySpan<byte> Label)
+    {
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str8,
+        };
+        m_commands.Add(new() { Label = cmd });
+    }
+
+    #endregion
+
+    #region Scope
+
+    public RenderDebugScope Scope(string Name)
+    {
+        if (!self.DebugEnabled) return new(self);
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+        self.m_render_debug_scope_count++;
+        return new(self);
+    }
+
+    public RenderDebugScope Scope(ReadOnlySpan<byte> Name)
+    {
+        if (!self.DebugEnabled) return new(self);
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str8,
+        };
+        m_commands.Add(new() { Label = cmd });
+        self.m_render_debug_scope_count++;
+        return new(self);
+    }
+
+    #endregion
+
+    #endregion
+
+    #region SetPipeline
+
+    public void SetPipeline(ShaderPipeline Pipeline)
+    {
+        if (m_current_pipeline == Pipeline) return;
+        self.AddObject(m_current_pipeline = Pipeline);
+        if (m_current_binding != null)
+        {
+            if (Pipeline.Shader.Layout != m_current_binding.Layout)
+                m_current_binding = null;
+        }
+        var cmd = new FCommandSetPipeline
+        {
+            Base = { Type = FCommandType.SetPipeline },
+            Pipeline = Pipeline.m_ptr,
+        };
+        m_commands.Add(new() { SetPipeline = cmd });
+    }
+
+    #endregion
+
+    #region SetBinding
+
+    public void SetBinding(ShaderBinding Binding)
+    {
+        if (m_current_binding == Binding) return;
+        if (m_current_pipeline != null)
+        {
+            if (m_current_pipeline.Shader.Layout != Binding.Layout)
+                throw new ArgumentException("This binding is incompatible with the current pipeline");
+        }
+        self.AddObject(m_current_binding = Binding);
+        var cmd = new FCommandSetBinding
+        {
+            Base = { Type = FCommandType.SetBinding },
+            Binding = Binding.m_ptr,
+        };
+        m_commands.Add(new() { SetBinding = cmd });
+    }
+
+    #endregion
+
+    #region SetViewportScissor
+
+    public void SetViewportScissor(
+        ReadOnlySpan<UViewPort> Viewports,
+        ReadOnlySpan<URect> Scissors
+    )
+    {
+        var cmd = new FCommandSetViewportScissor
+        {
+            Base = { Type = FCommandType.SetViewportScissor },
+            ViewportCount = (uint)Viewports.Length,
+            ScissorRectCount = (uint)Scissors.Length,
+        };
+        if (Viewports.Length > 0)
+        {
+            cmd.ViewportIndex = (uint)self.m_viewports.Count;
+            self.m_viewports.AddRange(MemoryMarshal.Cast<UViewPort, FViewport>(Viewports));
+        }
+        if (Scissors.Length > 0)
+        {
+            cmd.ScissorRectIndex = (uint)self.m_rects.Count;
+            self.m_rects.AddRange(MemoryMarshal.Cast<URect, FRect>(Scissors));
+        }
+        m_commands.Add(new() { SetViewportScissor = cmd });
+    }
+
+    #endregion
+
+    #region SetMeshBuffers
+
+    public void SetMeshBuffers(
+        MeshLayout MeshLayout,
         uint VertexStartSlot,
-        ReadOnlySpan<VertexBufferRange> VertexBuffers,
-        CommandFlags Flags = CommandFlags.None
-    ) => SetMeshBuffers(MeshLayout, FGraphicsFormat.Unknown, null, VertexStartSlot, VertexBuffers, Flags);
+        ReadOnlySpan<VertexBufferRange> VertexBuffers
+    ) => SetMeshBuffers(MeshLayout, FGraphicsFormat.Unknown, null, VertexStartSlot, VertexBuffers);
 
     public void SetMeshBuffers(
         MeshLayout MeshLayout,
-        ReadOnlySpan<VertexBufferRange> VertexBuffers,
-        CommandFlags Flags = CommandFlags.None
-    ) => SetMeshBuffers(MeshLayout, FGraphicsFormat.Unknown, null, 0, VertexBuffers, Flags);
+        ReadOnlySpan<VertexBufferRange> VertexBuffers
+    ) => SetMeshBuffers(MeshLayout, FGraphicsFormat.Unknown, null, 0, VertexBuffers);
 
     public void SetMeshBuffers(
         MeshLayout MeshLayout,
         FGraphicsFormat IndexFormat,
         BufferRange<IIbv>? IndexBuffer,
         uint VertexStartSlot,
-        ReadOnlySpan<VertexBufferRange> VertexBuffers,
-        CommandFlags Flags = CommandFlags.None
+        ReadOnlySpan<VertexBufferRange> VertexBuffers
     )
     {
-        AddObject(MeshLayout);
+        self.AddObject(MeshLayout);
         var cmd = new FCommandSetMeshBuffers
         {
-            MeshLayout = MeshLayout.m_ptr,
+            Base = { Type = FCommandType.SetMeshBuffers },
             IndexFormat = IndexFormat,
-            IndexBuffer = IndexBuffer is { } index_buffer
-                ? new()
-                {
-                    Buffer = new(AddResource(index_buffer.Buffer)),
-                    Offset = index_buffer.Offset,
-                    Size = index_buffer.Size == uint.MaxValue ? (uint)index_buffer.Buffer.LongSize : index_buffer.Size,
-                }
-                : new()
-                {
-                    Buffer = new(uint.MaxValue),
-                },
             VertexStartSlot = VertexStartSlot,
+            PayloadIndex = (uint)self.m_mesh_buffers.Count,
+        };
+        var buf = new FMeshBuffers
+        {
+            MeshLayout = MeshLayout.m_ptr,
             VertexBufferCount = (uint)VertexBuffers.Length,
         };
+        if (IndexBuffer is { } index_buffer)
+        {
+            buf.IndexBuffer = new()
+            {
+                Buffer = self.AddResource(index_buffer.Buffer.Resource),
+                Offset = index_buffer.Offset,
+                Size = index_buffer.Size == uint.MaxValue ? (uint)index_buffer.Buffer.Size : index_buffer.Size,
+            };
+            ref var old_state = ref self.RecordScopedResState(
+                buf.IndexBuffer.Buffer, new(
+                    ScopedStateUsage.Vertex, ResLayout.None, ResAccess.IndexBuffer, LegacyState.IndexBuffer
+                ), out var compatible
+            );
+            if (!compatible)
+                throw self.Incompatible("Index buffer", old_state, LegacyState.IndexBuffer, ResAccess.IndexBuffer);
+        }
         if (VertexBuffers.Length > 0)
         {
-            cmd.VertexBuffersIndex = (uint)m_payload.Count;
-            Span<FVertexBufferRange> vbs = stackalloc FVertexBufferRange[VertexBuffers.Length];
+            var index = self.m_vertex_buffer_ranges.Count;
+            buf.VertexBuffersIndex = (uint)index;
+            CollectionsMarshal.SetCount(
+                self.m_vertex_buffer_ranges, self.m_vertex_buffer_ranges.Count + VertexBuffers.Length
+            );
+            var vbs = CollectionsMarshal.AsSpan(self.m_vertex_buffer_ranges).Slice(index, VertexBuffers.Length);
             for (var i = 0; i < VertexBuffers.Length; i++)
             {
                 var buffer = VertexBuffers[i];
-                vbs[i] = new()
+                ref var dst = ref vbs[i];
+                dst = new()
                 {
                     Base =
                     {
-                        Buffer = new(AddResource(buffer.Buffer)),
+                        Buffer = self.AddResource(buffer.Buffer.Resource),
                         Offset = buffer.Offset,
-                        Size = buffer.Size == uint.MaxValue ? (uint)buffer.Buffer.LongSize : buffer.Size,
+                        Size = buffer.Size == uint.MaxValue ? (uint)buffer.Buffer.Size : buffer.Size,
                     },
                     Index = buffer.Index,
                 };
+                ref var old_state = ref self.RecordScopedResState(
+                    dst.Base.Buffer, new(
+                        ScopedStateUsage.Vertex, ResLayout.None, ResAccess.VertexBuffer, LegacyState.VertexBuffer
+                    ), out var compatible
+                );
+                if (!compatible)
+                    throw self.Incompatible(
+                        "Vertex buffer", old_state, LegacyState.VertexBuffer, ResAccess.IndexBuffer
+                    );
             }
-            m_payload.AddRange(MemoryMarshal.AsBytes(vbs));
-        }
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.SetMeshBuffers,
-                Flags = (FCommandFlags)Flags,
-                SetMeshBuffers = cmd,
-            }
-        );
-        if (IndexBuffer.HasValue)
-        {
-            IndexBuffer.Value.Buffer.UnsafeChangeState(FResourceState.IndexBuffer);
-        }
-        foreach (var buffer in VertexBuffers)
-        {
-            buffer.Buffer.UnsafeChangeState(FResourceState.VertexBuffer);
         }
+        self.m_mesh_buffers.Add(buf);
+        m_commands.Add(new() { SetMeshBuffers = cmd });
     }
 
     #endregion
@@ -444,52 +1733,52 @@ public void SetMeshBuffers(
     public void Draw(
         uint VertexCount, uint InstanceCount = 1,
         uint FirstVertex = 0, uint FirstInstance = 0,
-        CommandFlags Flags = CommandFlags.None
-    ) => Draw(null, false, VertexCount, InstanceCount, FirstVertex, FirstInstance, 0, Flags);
+        ShaderBinding? Binding = null
+    ) => Draw(null, false, VertexCount, InstanceCount, FirstVertex, FirstInstance, 0, Binding);
 
     public void Draw(
         ShaderPipeline? Pipeline,
         uint VertexCount, uint InstanceCount = 1,
         uint FirstVertex = 0, uint FirstInstance = 0,
-        CommandFlags Flags = CommandFlags.None
-    ) => Draw(Pipeline, false, VertexCount, InstanceCount, FirstVertex, FirstInstance, 0, Flags);
+        ShaderBinding? Binding = null
+    ) => Draw(Pipeline, false, VertexCount, InstanceCount, FirstVertex, FirstInstance, 0, Binding);
 
     public void DrawIndexed(
         uint IndexCount, uint InstanceCount = 1,
         uint FirstIndex = 0, uint FirstInstance = 0, uint VertexOffset = 0,
-        CommandFlags Flags = CommandFlags.None
-    ) => Draw(null, true, IndexCount, InstanceCount, FirstIndex, FirstInstance, VertexOffset, Flags);
+        ShaderBinding? Binding = null
+    ) => Draw(null, true, IndexCount, InstanceCount, FirstIndex, FirstInstance, VertexOffset, Binding);
 
     public void DrawIndexed(
         ShaderPipeline? Pipeline,
         uint IndexCount, uint InstanceCount = 1,
         uint FirstIndex = 0, uint FirstInstance = 0, uint VertexOffset = 0,
-        CommandFlags Flags = CommandFlags.None
-    ) => Draw(Pipeline, true, IndexCount, InstanceCount, FirstIndex, FirstInstance, VertexOffset, Flags);
+        ShaderBinding? Binding = null
+    ) => Draw(Pipeline, true, IndexCount, InstanceCount, FirstIndex, FirstInstance, VertexOffset, Binding);
 
     public void Draw(
         ShaderPipeline? Pipeline, bool Indexed,
         uint VertexOrIndexCount, uint InstanceCount = 1,
         uint FirstVertexOrIndex = 0, uint FirstInstance = 0, uint VertexOffset = 0,
-        CommandFlags Flags = CommandFlags.None
+        ShaderBinding? Binding = null
     )
     {
         if (Pipeline != null)
         {
-            m_current_pipeline = Pipeline;
             if (!Pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Vertex))
-                throw new ArgumentException("Non Vertex pipelines cannot use Draw");
-            AddObject(Pipeline);
+                throw new ArgumentException("Only Vertex shaders can use Draw");
+            SetPipeline(Pipeline);
         }
         else
         {
             if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
             if (!m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Vertex))
-                throw new ArgumentException("Non Vertex pipelines cannot use Draw");
+                throw new ArgumentException("Only Vertex shaders can use Draw");
         }
+        if (Binding != null) SetBinding(Binding);
         var cmd = new FCommandDraw
         {
-            Pipeline = Pipeline == null ? null : Pipeline.m_ptr,
+            Base = { Type = FCommandType.Draw },
             VertexOrIndexCount = VertexOrIndexCount,
             InstanceCount = InstanceCount,
             FirstVertexOrIndex = FirstVertexOrIndex,
@@ -497,210 +1786,309 @@ public void Draw(
             VertexOffset = VertexOffset,
             Indexed = Indexed,
         };
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.Draw,
-                Flags = (FCommandFlags)Flags,
-                Draw = cmd,
-            }
-        );
+        m_commands.Add(new() { Draw = cmd });
+        m_has_pixel_shader = true;
+        m_has_vertex_shader = true;
     }
 
     #endregion
 
-    #region Dispatch
-
-    public void Dispatch(
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
-        CommandFlags Flags = CommandFlags.None
-    ) => Dispatch(null, DispatchType.Compute);
+    #region DispatchMesh
 
     public void DispatchMesh(
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
-        CommandFlags Flags = CommandFlags.None
-    ) => Dispatch(null, DispatchType.Mesh);
-
-    public void Dispatch(
-        ShaderPipeline Pipeline,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
-        CommandFlags Flags = CommandFlags.None
-    ) => Dispatch(Pipeline, DispatchType.Auto);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    ) => DispatchMesh(null, GroupCountX, GroupCountY, GroupCountZ);
 
-    public void Dispatch(
-        ShaderPipeline? Pipeline, DispatchType Type,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
-        CommandFlags Flags = CommandFlags.None
+    public void DispatchMesh(
+        ShaderPipeline? Pipeline,
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
     )
     {
         if (Pipeline != null)
         {
-            m_current_pipeline = Pipeline;
-            if (!Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
-                throw new ArgumentException("Non Mesh and Compute pipelines cannot use Dispatch");
-            AddObject(Pipeline);
-            if (Type == DispatchType.Auto)
-            {
-                if (Pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Compute)) Type = DispatchType.Compute;
-                else if (Pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh)) Type = DispatchType.Mesh;
-                else throw new UnreachableException();
-            }
+            if (!Pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only Mesh shaders can use DispatchMesh");
+            SetPipeline(Pipeline);
         }
         else
         {
             if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
-            if (!m_current_pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
-                throw new ArgumentException("Non Mesh and Compute pipelines cannot use Dispatch");
-            if (Type == DispatchType.Auto)
-            {
-                if (m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Compute)) Type = DispatchType.Compute;
-                else if (m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh)) Type = DispatchType.Mesh;
-                else throw new UnreachableException();
-            }
+            if (!m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only Mesh shaders can use DispatchMesh");
         }
         var cmd = new FCommandDispatch
         {
-            Pipeline = Pipeline == null ? null : Pipeline.m_ptr,
+            Base = { Type = FCommandType.Draw },
             GroupCountX = GroupCountX,
             GroupCountY = GroupCountY,
             GroupCountZ = GroupCountZ,
-            Type = Type switch
-            {
-                DispatchType.Auto    => throw new UnreachableException(),
-                DispatchType.Compute => FDispatchType.Compute,
-                DispatchType.Mesh    => FDispatchType.Mesh,
-                _                    => throw new ArgumentOutOfRangeException(nameof(Type), Type, null)
-            },
+            Type = FDispatchType.Mesh,
         };
-        m_commands.Add(
-            new()
+        m_commands.Add(new() { Dispatch = cmd });
+        m_has_pixel_shader = true;
+        m_has_mesh_shader = true;
+        m_has_task_shader = m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Task);
+    }
+
+    #endregion
+}
+
+#endregion
+
+#region ComputeScope
+
+public unsafe struct ComputeScope(
+    CommandList self,
+    int info_index,
+    FCommandCompute compute_cmd,
+    List<FComputeCommandItem> m_commands,
+    bool debug_scope
+) : IDisposable
+{
+    #region Fields
+
+    internal FCommandCompute compute_cmd = compute_cmd;
+    internal ShaderPipeline? m_current_pipeline;
+    internal ShaderBinding? m_current_binding;
+    internal bool m_disposed;
+    internal bool m_has_compute_shader;
+    internal bool m_has_mesh_shader;
+    internal bool m_has_task_shader;
+
+    #endregion
+
+    #region Props
+
+    internal ref FComputeInfo Info => ref CollectionsMarshal.AsSpan(self.m_compute_infos)[info_index];
+
+    #endregion
+
+    #region Dispose
+
+    public void Dispose()
+    {
+        if (m_disposed) throw new ObjectDisposedException(nameof(ComputeScope));
+        m_disposed = true;
+        if (self.m_compute_debug_scope_count != 0)
+            throw new InvalidOperationException(
+                "There is still Debug scope not ended, please check whether Dispose is missed."
+            );
+        if (self.AutoBarrierEnabled)
+        {
+            foreach (var (res, scoped_state) in self.m_scoped_res_state)
             {
-                Type = FCommandType.Dispatch,
-                Flags = (FCommandFlags)Flags,
-                Dispatch = cmd,
+                ref var state = ref self.StateAt(res);
+                var stages = ShaderStageFlags.None;
+                if (m_has_compute_shader && (scoped_state.Usage & ScopedStateUsage.Compute) != 0)
+                    stages |= ShaderStageFlags.Compute;
+                if (m_has_mesh_shader && (scoped_state.Usage & ScopedStateUsage.Mesh) != 0)
+                    stages |= ShaderStageFlags.Mesh;
+                if (m_has_task_shader && (scoped_state.Usage & ScopedStateUsage.Mesh) != 0)
+                    stages |= ShaderStageFlags.Task;
+                state.ReqState(
+                    self,
+                    scoped_state.Layout.ToFFI(),
+                    scoped_state.Access.ToFFI(),
+                    stages.ToFFI(),
+                    scoped_state.Legacy.ToFFI()
+                );
             }
-        );
+            foreach (var res in self.m_scoped_res_state.Keys)
+            {
+                ref var state = ref self.StateAt(res);
+                state.MarkUse(self);
+            }
+        }
+        compute_cmd.CommandCount = (uint)m_commands.Count - compute_cmd.CommandStartIndex;
+        self.m_commands.Add(new() { Compute = compute_cmd });
+        self.m_in_render_or_compute_scope = false;
+        if (debug_scope) new DebugScope(self).Dispose();
+        self.m_scoped_res_state.Clear();
     }
 
     #endregion
 
-    #region BufferCopy
+    #region Debug
 
-    public void Copy(
-        GpuBuffer Dst,
-        GpuBuffer Src,
-        ulong DstOffset = 0,
-        ulong SrcOffset = 0,
-        ulong Size = ulong.MaxValue,
-        CommandFlags Flags = CommandFlags.None
-    )
+    #region Label
+
+    public void Label(string Label)
     {
-        if (Size != ulong.MaxValue)
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandLabel
         {
-            if (DstOffset + Size > Dst.Size) throw new ArgumentException("The copy range exceeds the buffer range");
-            if (SrcOffset + Size > Src.Size) throw new ArgumentException("The copy range exceeds the buffer range");
-        }
-        else if (Dst == Src || Dst.Size != Src.Size) Size = Math.Min(Dst.Size, Src.Size);
-        var dst = AddResource(Dst);
-        var src = AddResource(Src);
-        var cmd = new FCommandBufferCopy
+            Base = { Type = FCommandType.Label },
+            StringIndex = self.AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+    }
+
+    public void Label(ReadOnlySpan<byte> Label)
+    {
+        if (!self.DebugEnabled) return;
+        var cmd = new FCommandLabel
         {
-            Size = Size,
-            DstOffset = DstOffset,
-            SrcOffset = SrcOffset,
-            DstType = FBufferRefType.Buffer,
-            SrcType = FBufferRefType.Buffer,
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Label),
+            StringLength = (uint)Label.Length,
+            StrType = FStrType.Str8,
         };
-        cmd.Dst.Buffer = new(dst);
-        cmd.Src.Buffer = new(src);
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.BufferCopy,
-                Flags = (FCommandFlags)Flags,
-                BufferCopy = cmd,
-            }
-        );
-        Dst.UnsafeChangeState(FResourceState.CopyDst);
-        Src.UnsafeChangeState(FResourceState.CopySrc);
+        m_commands.Add(new() { Label = cmd });
     }
 
     #endregion
 
-    #region BufferUpload
+    #region Scope
 
-    public void Upload<T>(
-        GpuBuffer Dst,
-        ReadOnlySpan<T> Data,
-        ulong DstOffset = 0,
-        CommandFlags Flags = CommandFlags.None
-    ) where T : unmanaged => Upload(Dst, MemoryMarshal.AsBytes(Data), DstOffset, Flags);
+    public ComputeDebugScope Scope(string Name)
+    {
+        if (!self.DebugEnabled) return new(self);
+        var cmd = new FCommandLabel
+        {
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str16,
+        };
+        m_commands.Add(new() { Label = cmd });
+        self.m_compute_debug_scope_count++;
+        return new(self);
+    }
 
-    public void Upload(
-        GpuBuffer Dst,
-        ReadOnlySpan<byte> Data,
-        ulong DstOffset = 0,
-        CommandFlags Flags = CommandFlags.None
-    )
+    public ComputeDebugScope Scope(ReadOnlySpan<byte> Name)
     {
-        if (Data.Length == 0) return;
-        var Size = Math.Min(Dst.Size, (uint)Data.Length);
-        var dst = AddResource(Dst);
-        var src = m_queue.WriteToUpload(Data);
-        var cmd = new FCommandBufferCopy
+        if (!self.DebugEnabled) return new(self);
+        var cmd = new FCommandLabel
         {
-            Size = Size,
-            DstOffset = DstOffset,
-            SrcOffset = src.Offset,
-            DstType = FBufferRefType.Buffer,
-            SrcType = FBufferRefType.Upload,
+            Base = { Type = FCommandType.EndScope },
+            StringIndex = self.AddString(Name),
+            StringLength = (uint)Name.Length,
+            StrType = FStrType.Str8,
         };
-        cmd.Dst.Buffer = new(dst);
-        cmd.Src.Upload = new(src);
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.BufferCopy,
-                Flags = (FCommandFlags)Flags,
-                BufferCopy = cmd,
-            }
-        );
-        Dst.UnsafeChangeState(FResourceState.CopyDst);
+        m_commands.Add(new() { Label = cmd });
+        self.m_compute_debug_scope_count++;
+        return new(self);
     }
 
-    public void Upload(
-        GpuBuffer Dst,
-        UploadLoc Loc,
-        ulong DstOffset = 0,
-        CommandFlags Flags = CommandFlags.None
-    )
+    #endregion
+
+    #endregion
+
+    #region SetPipeline
+
+    public void SetPipeline(ShaderPipeline Pipeline)
     {
-        if (Loc.SubmitId != m_queue.SubmitId)
-            throw new ArgumentException("An attempt was made to use an expired upload location");
-        var Size = Math.Min(Dst.Size, Loc.Size);
-        var dst = AddResource(Dst);
-        var cmd = new FCommandBufferCopy
+        if (m_current_pipeline == Pipeline) return;
+        self.AddObject(m_current_pipeline = Pipeline);
+        if (m_current_binding != null)
         {
-            Size = Size,
-            DstOffset = DstOffset,
-            SrcOffset = Loc.Offset,
-            DstType = FBufferRefType.Buffer,
-            SrcType = FBufferRefType.Upload,
+            if (Pipeline.Shader.Layout != m_current_binding.Layout)
+                m_current_binding = null;
+        }
+        var cmd = new FCommandSetPipeline
+        {
+            Base = { Type = FCommandType.SetPipeline },
+            Pipeline = Pipeline.m_ptr,
         };
-        cmd.Dst.Buffer = new(dst);
-        cmd.Src.Upload = new(Loc);
-        m_commands.Add(
-            new()
-            {
-                Type = FCommandType.BufferCopy,
-                Flags = (FCommandFlags)Flags,
-                BufferCopy = cmd,
-            }
-        );
-        Dst.UnsafeChangeState(FResourceState.CopyDst);
+        m_commands.Add(new() { SetPipeline = cmd });
     }
 
     #endregion
 
+    #region SetBinding
+
+    public void SetBinding(ShaderBinding Binding)
+    {
+        if (m_current_binding == Binding) return;
+        if (m_current_pipeline != null)
+        {
+            if (m_current_pipeline.Shader.Layout != Binding.Layout)
+                throw new ArgumentException("This binding is incompatible with the current pipeline");
+        }
+        self.AddObject(m_current_binding = Binding);
+        var cmd = new FCommandSetBinding
+        {
+            Base = { Type = FCommandType.SetBinding },
+            Binding = Binding.m_ptr,
+        };
+        m_commands.Add(new() { SetBinding = cmd });
+    }
+
+    #endregion
+
+    #region Dispatch
+
+    public void Dispatch(
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    ) => Dispatch(null, DispatchType.Compute, GroupCountX, GroupCountY, GroupCountZ);
+
+    public void DispatchMesh(
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    ) => Dispatch(null, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ);
+
+    public void Dispatch(
+        ShaderPipeline Pipeline,
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    ) => Dispatch(Pipeline, DispatchType.Auto, GroupCountX, GroupCountY, GroupCountZ);
+
+    public void DispatchMesh(
+        ShaderPipeline Pipeline,
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    ) => Dispatch(Pipeline, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ);
+
+    public void Dispatch(
+        ShaderPipeline? Pipeline, DispatchType Type,
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+    )
+    {
+        if (Pipeline != null)
+        {
+            if (!Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only Mesh and Compute shaders can use Dispatch/DispatchMesh");
+            SetPipeline(Pipeline);
+        }
+        else
+        {
+            if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
+            if (!m_current_pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only Mesh and Compute shaders can use Dispatch/DispatchMesh");
+        }
+        if (Type == DispatchType.Auto)
+        {
+            if (m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute)) Type = DispatchType.Compute;
+            else if (m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh)) Type = DispatchType.Mesh;
+            else throw new UnreachableException();
+        }
+        else if (Type == DispatchType.Mesh)
+        {
+            if (!m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only Mesh shaders can use DispatchMesh");
+        }
+        else if (Type == DispatchType.Compute)
+        {
+            if (!m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute))
+                throw new ArgumentException("Only Compute shaders can use Dispatch");
+        }
+        var cmd = new FCommandDispatch
+        {
+            Base = { Type = FCommandType.SetBinding },
+            GroupCountX = GroupCountX,
+            GroupCountY = GroupCountY,
+            GroupCountZ = GroupCountZ,
+            Type = Type switch
+            {
+                DispatchType.Auto    => throw new UnreachableException(),
+                DispatchType.Compute => FDispatchType.Compute,
+                DispatchType.Mesh    => FDispatchType.Mesh,
+                _                    => throw new ArgumentOutOfRangeException(nameof(Type), Type, null)
+            },
+        };
+        m_commands.Add(new() { Dispatch = cmd });
+    }
+
     #endregion
 }
+
+#endregion
diff --git a/Coplt.Graphics.Core/Core/DeviceRequires.cs b/Coplt.Graphics.Core/Core/DeviceRequires.cs
new file mode 100644
index 0000000..59ce7a3
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/DeviceRequires.cs
@@ -0,0 +1,143 @@
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+public enum D3dFeatureLevel
+{
+    Unset = 0,
+    _12_1 = 0xc100,
+    _12_2 = 0xc200,
+}
+
+public enum VulkanVersion
+{
+    Unset = 0,
+    _1_2 = 1002,
+    _1_3 = 1003,
+    _1_4 = 1004,
+}
+
+public enum DeviceTypeRequire : byte
+{
+    Any,
+    Gpu,
+    IntegratedGpu,
+    DiscreteGpu,
+    VirtualGpu,
+    Cpu,
+}
+
+public enum DeviceType : byte
+{
+    Other,
+    IntegratedGpu,
+    DiscreteGpu,
+    VirtualGpu,
+    Cpu,
+}
+
+public enum Backend : byte
+{
+    None,
+    Dx12,
+    Vulkan,
+};
+
+public record struct DeviceRequires
+{
+    public D3dFeatureLevel D3dFeatureLevel;
+    public VulkanVersion VulkanVersion;
+    public DeviceTypeRequire DeviceType;
+    public DeviceFeatureRequires FeatureRequires;
+}
+
+public enum ShaderModelLevel : uint
+{
+    Any = 0,
+    SM_5_1 = 0x51,
+    SM_6_0 = 0x60,
+    SM_6_1 = 0x61,
+    SM_6_2 = 0x62,
+    SM_6_3 = 0x63,
+    SM_6_4 = 0x64,
+    SM_6_5 = 0x65,
+    SM_6_6 = 0x66,
+    SM_6_7 = 0x67,
+    SM_6_8 = 0x68,
+    SM_6_9 = 0x69,
+};
+
+public record struct DeviceFeatureRequires
+{
+    /// <summary>
+    /// 兼容的 hlsl 着色器模型级别
+    /// </summary>
+    public ShaderModelLevel ShaderModelLevel;
+    /// <summary>
+    /// 光追
+    /// </summary>
+    public bool RayTracing;
+    /// <summary>
+    /// 网格着色器
+    /// </summary>
+    public bool MeshShader;
+    /// <summary>
+    /// 描述符堆，dx 后端忽略，vk 使用 VK_EXT_descriptor_buffer
+    /// </summary>
+    public bool DescriptorHeap;
+    /// <summary>
+    /// 增强屏障，vk 后端忽略
+    /// </summary>
+    public bool EnhancedBarriers;
+    /// <summary>
+    /// 假 · 无绑定, dx 后端后端忽略
+    /// </summary>
+    public bool ArrBindless;
+    /// <summary>
+    /// 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
+    /// </summary>
+    public bool DynBindless;
+}
+
+public record struct DeviceFeatures
+{
+    /// <summary>
+    /// 兼容的 hlsl 着色器模型级别
+    /// </summary>
+    public ShaderModelLevel ShaderModelLevel;
+    /// <summary>
+    /// 光追
+    /// </summary>
+    public bool RayTracing;
+    /// <summary>
+    /// 网格着色器
+    /// </summary>
+    public bool MeshShader;
+    /// <summary>
+    /// 描述符堆，dx 后端忽略，vk 使用 VK_EXT_descriptor_buffer
+    /// </summary>
+    public bool DescriptorHeap;
+    /// <summary>
+    /// 增强屏障，vk 后端忽略
+    /// </summary>
+    public bool EnhancedBarriers;
+    /// <summary>
+    /// 假 · 无绑定, dx 后端后端忽略
+    /// </summary>
+    public bool ArrBindless;
+    /// <summary>
+    /// 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
+    /// </summary>
+    public bool DynBindless;
+
+    public DeviceFeatures(in FDeviceFeatures native)
+    {
+        ShaderModelLevel = (ShaderModelLevel)native.ShaderModelLevel;
+        RayTracing = native.RayTracing;
+        MeshShader = native.MeshShader;
+        DescriptorHeap = native.DescriptorHeap;
+        EnhancedBarriers = native.EnhancedBarriers;
+        ArrBindless = native.ArrBindless;
+        DynBindless = native.DynBindless;
+    }
+}
diff --git a/Coplt.Graphics.Core/Core/GpuAdapter.cs b/Coplt.Graphics.Core/Core/GpuAdapter.cs
new file mode 100644
index 0000000..12a6d97
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/GpuAdapter.cs
@@ -0,0 +1,92 @@
+using Coplt.Dropping;
+using Coplt.Graphics.Native;
+using Coplt.Graphics.Utilities;
+
+namespace Coplt.Graphics.Core;
+
+[Dropping(Unmanaged = true)]
+public sealed unsafe partial class GpuAdapter
+{
+    #region Fields
+
+    internal FGpuAdapter* m_ptr;
+    internal readonly GraphicsInstance m_instance;
+    internal string? m_name;
+    internal string? m_driver;
+    internal string? m_driver_info;
+
+    #endregion
+
+    #region Props
+
+    public FGpuAdapter* Ptr => m_ptr;
+    public GraphicsInstance Instance => m_instance;
+    public string Name => m_name ??= m_ptr->m_name.ToString();
+    public string Driver => m_driver ??= m_ptr->m_driver.ToString();
+    public string DriverInfo => m_driver_info ??= m_ptr->m_driver_info.ToString();
+    public uint VendorId => m_ptr->m_vendor_id;
+    public uint DeviceId => m_ptr->m_device_id;
+    public D3dFeatureLevel D3dFeatureLevel => (D3dFeatureLevel)m_ptr->m_d3d_feature_level;
+    public VulkanVersion VulkanVersion => (VulkanVersion)m_ptr->m_vulkan_version;
+    public DeviceType DeviceType => (DeviceType)m_ptr->m_device_type;
+    public Backend Backend => (Backend)m_ptr->m_backend;
+    public DeviceFeatures Features => new(m_ptr->m_features);
+    public bool UseLegacyState => !m_ptr->m_features.EnhancedBarriers;
+
+    #endregion
+
+    #region Ctor
+
+    internal GpuAdapter(FGpuAdapter* ptr, GraphicsInstance instance)
+    {
+        m_ptr = ptr;
+        m_instance = instance;
+    }
+
+    #endregion
+
+    #region Drop
+
+    [Drop]
+    private void Drop()
+    {
+        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
+        ptr->Release();
+    }
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString() => string.IsNullOrEmpty(Name)
+        ? $"{nameof(GpuAdapter)}(0x{(nuint)m_ptr:X})"
+        : $"{nameof(GpuAdapter)}({Name})";
+
+    #endregion
+
+    #region CreateDevice
+
+    public GpuDevice CreateDevice(
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    )
+    {
+        var QueueName = !Instance.DebugEnabled || Name is null ? null : $"{Name} Main Queue";
+        var QueueName8 = !Instance.DebugEnabled || Name8.Length == 0
+            ? Name8
+            : Utils.JoinUtf8String(Name8, " Main Queue"u8);
+
+        fixed (char* p_name = Name)
+        fixed (byte* p_name8 = Name8)
+        {
+            FGpuDeviceCreateOptions f_options = new()
+            {
+                Name = new(Name, Name8, p_name, p_name8),
+            };
+            FGpuDevice* ptr;
+            m_ptr->CreateDevice(&f_options, &ptr).TryThrow();
+            return new(ptr, Instance, this, Name, QueueName: QueueName, QueueName8: QueueName8);
+        }
+    }
+
+    #endregion
+}
diff --git a/Coplt.Graphics.Core/Core/GpuBuffer.cs b/Coplt.Graphics.Core/Core/GpuBuffer.cs
index df8b0fc..e1514f6 100644
--- a/Coplt.Graphics.Core/Core/GpuBuffer.cs
+++ b/Coplt.Graphics.Core/Core/GpuBuffer.cs
@@ -5,10 +5,8 @@ namespace Coplt.Graphics.Core;
 
 public record struct GpuBufferCreateOptions()
 {
-    public Str8or16 Name;
     public required ResourcePurpose Purpose;
     public CpuAccess CpuAccess = CpuAccess.None;
-    public LifeTime LifeTime = LifeTime.Common;
     public required ulong Size;
     public uint Count;
     public uint Stride;
@@ -16,7 +14,7 @@ public record struct GpuBufferCreateOptions()
 }
 
 [Dropping(Unmanaged = true)]
-public sealed unsafe partial class GpuBuffer : GpuResource, ICbv, ISrv, IUav, IRtv, IIbv, IVbv
+public sealed unsafe partial class GpuBuffer : GpuResource, IGpuResource, ICbv, ISrv, IUav, IRtv, IIbv, IVbv
 {
     #region Fields
 
@@ -28,11 +26,22 @@ public sealed unsafe partial class GpuBuffer : GpuResource, ICbv, ISrv, IUav, IR
 
     public new FGpuBuffer* Ptr => m_ptr;
     public ulong Size => m_ptr->m_size;
-    ulong IView.LongSize => Size;
-    uint3 IView.Size => new((uint)Size, 1, 1);
+    GraphicsFormat IGpuView.Format => GraphicsFormat.Unknown;
+    uint IGpuView.Width => (uint)Size;
+    uint IGpuView.Height => 1;
+    uint IGpuView.DepthOrLength => 1;
+    uint IGpuView.MipLevels => 1;
+    uint IGpuView.Planes => 1;
     public uint Count => m_ptr->m_count;
     public uint Stride => m_ptr->m_stride;
     public BufferUsage Usage => (BufferUsage)m_ptr->m_usage;
+    GpuResourceType IGpuResource.Type => GpuResourceType.Buffer;
+    IGpuResource IGpuView.Resource => this;
+    FResourceMeta IGpuResource.GetMeta() => new()
+    {
+        Type = FResourceRefType.Buffer,
+        Buffer = m_ptr,
+    };
 
     #endregion
 
@@ -66,15 +75,6 @@ m_name is null
 
     #region View
 
-    FResourceMeta IView.GetMeta() => new()
-    {
-        CurrentState = m_ptr->Base.m_state,
-        Type = FResourceRefType.Buffer,
-        Buffer = m_ptr,
-    };
-    void IView.UnsafeChangeState(FResourceState state) => UnsafeChangeState(state);
-    internal void UnsafeChangeState(FResourceState state) => m_ptr->Base.m_state.ChangeState(state);
-
     public bool TryVbv() => Purpose.HasFlags(ResourcePurpose.VertexBuffer);
     public bool TryIbv() => Purpose.HasFlags(ResourcePurpose.IndexBuffer);
     public bool TryRtv() => Purpose.HasFlags(ResourcePurpose.RenderTarget);
diff --git a/Coplt.Graphics.Core/Core/GpuDevice.cs b/Coplt.Graphics.Core/Core/GpuDevice.cs
index 4278104..b4fb555 100644
--- a/Coplt.Graphics.Core/Core/GpuDevice.cs
+++ b/Coplt.Graphics.Core/Core/GpuDevice.cs
@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Text;
 using Coplt.Dropping;
@@ -8,42 +9,6 @@
 
 namespace Coplt.Graphics.Core;
 
-#region Enums
-
-public enum D3dFeatureLevel
-{
-    Unset = 0,
-    _12_1 = 0xc100,
-    _12_2 = 0xc200,
-}
-
-public enum VulkanVersion
-{
-    Unset = 0,
-    _1_2 = 1002,
-    _1_3 = 1003,
-    _1_4 = 1004,
-}
-
-public enum GpuPreference : byte
-{
-    HighPerformance = 0,
-    MinimumPower = 1,
-    Any = 255,
-}
-
-#endregion
-
-#region GpuDeviceOptions
-
-public record struct GpuDeviceOptions
-{
-    public VulkanVersion VulkanVersion;
-    public D3dFeatureLevel D3dFeatureLevel;
-}
-
-#endregion
-
 [Dropping(Unmanaged = true)]
 public sealed unsafe partial class GpuDevice
 {
@@ -51,6 +16,7 @@ public sealed unsafe partial class GpuDevice
 
     internal FGpuDevice* m_ptr;
     internal readonly GraphicsInstance m_instance;
+    internal readonly GpuAdapter m_adapter;
     internal string? m_name;
     [Drop]
     internal readonly GpuQueue m_main_queue;
@@ -61,6 +27,7 @@ public sealed unsafe partial class GpuDevice
 
     public FGpuDevice* Ptr => m_ptr;
     public GraphicsInstance Instance => m_instance;
+    public GpuAdapter Adapter => m_adapter;
     public GpuQueue MainQueue => m_main_queue;
     public CommandList MainCommandList => MainQueue.CommandList;
 
@@ -69,13 +36,14 @@ public sealed unsafe partial class GpuDevice
     #region Ctor
 
     internal GpuDevice(
-        FGpuDevice* ptr, GraphicsInstance instance,
+        FGpuDevice* ptr, GraphicsInstance instance, GpuAdapter? adapter,
         string? name, string? QueueName = null, ReadOnlySpan<byte> QueueName8 = default
     )
     {
         m_instance = instance;
         m_name = name;
         m_ptr = ptr;
+        m_adapter = adapter ?? m_instance.m_ptr_to_adapters[(nuint)m_ptr->GetAdapter()];
         m_main_queue = CreateMainQueue(Name: QueueName, Name8: QueueName8);
     }
 
@@ -99,7 +67,7 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
@@ -109,7 +77,7 @@ public void SetName(ReadOnlySpan<byte> name)
         m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
@@ -213,6 +181,22 @@ public ShaderLayout CreateShaderLayout(
         }
     }
 
+    private readonly ConcurrentDictionary<ShaderLayoutFlags, ShaderLayout> m_empty_shader_layouts = new();
+
+    public ShaderLayout GetEmptyShaderLayout(ShaderLayoutFlags Flags = ShaderLayoutFlags.None) =>
+        m_empty_shader_layouts.GetOrAdd(
+            Flags, static (flags, self) =>
+            {
+                FGetEmptyShaderLayoutOptions f_options = new()
+                {
+                    Flags = (FShaderLayoutFlags)flags,
+                };
+                FShaderLayout* ptr;
+                self.m_ptr->GetEmptyShaderLayout(&f_options, &ptr).TryThrow();
+                return new(ptr, $"Empty Shader Layout ({flags})");
+            }, this
+        );
+
     #endregion
 
     #region CreateShaderInputLayout
@@ -267,6 +251,10 @@ public ShaderInputLayout CreateShaderInputLayout(
         }
     }
 
+    private ShaderInputLayout? m_empty_shader_input_layout;
+    public ShaderInputLayout EmptyShaderInputLayout =>
+        m_empty_shader_input_layout ??= CreateShaderInputLayout([], "Empty Shader Input Layout");
+
     #endregion
 
     #region CreateShader
@@ -308,6 +296,15 @@ public Shader CreateShader(
 
     #endregion
 
+    #region CreateShaderBinding
+
+    public ShaderBinding CreateShaderBinding(
+        ShaderLayout Layout,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    ) => MainQueue.CreateShaderBinding(Layout, Name, Name8);
+
+    #endregion
+
     #region CreateMeshLayout
 
     public MeshLayout CreateMeshLayout(
diff --git a/Coplt.Graphics.Core/Core/GpuExecutor.cs b/Coplt.Graphics.Core/Core/GpuExecutor.cs
new file mode 100644
index 0000000..3cb245e
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/GpuExecutor.cs
@@ -0,0 +1,130 @@
+using Coplt.Dropping;
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+[Dropping(Unmanaged = true)]
+public abstract unsafe partial class GpuExecutor
+{
+    #region Fields
+
+    internal FGpuExecutor* m_ptr;
+    internal string? m_name;
+    internal readonly GpuQueue m_queue;
+    internal CommandList? m_recycle_cmd_list;
+    internal readonly Lock m_wait_lock = new();
+
+    #endregion
+
+    #region Props
+
+    public FGpuExecutor* Ptr => m_ptr;
+    public GpuDevice Device => m_queue.m_device;
+    public GpuQueue Queue => m_queue;
+
+    public bool NeedWait => m_recycle_cmd_list != null;
+
+    #endregion
+
+    #region Ctor
+
+    internal GpuExecutor(FGpuExecutor* ptr, string? name, GpuQueue queue)
+    {
+        m_ptr = ptr;
+        m_name = name;
+        m_queue = queue;
+    }
+
+    #endregion
+
+    #region Drop
+
+    [Drop]
+    private void Drop()
+    {
+        Wait(true);
+        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
+        ptr->Release();
+    }
+
+    #endregion
+
+    #region SetName
+
+    public void SetName(string name)
+    {
+        m_name = name;
+        fixed (char* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    public void SetName(ReadOnlySpan<byte> name)
+    {
+        m_name = null;
+        fixed (byte* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString() =>
+        m_name is null
+            ? $"{nameof(GpuExecutor)}(0x{(nuint)m_ptr:X})"
+            : $"{nameof(GpuExecutor)}(0x{(nuint)m_ptr:X} \"{m_name}\")";
+
+    #endregion
+
+    #region SetNeedWait
+
+    internal void SetNeedWait(CommandList cmd)
+    {
+        if (Interlocked.CompareExchange(ref m_recycle_cmd_list, cmd, null) != null)
+            throw new InvalidOperationException("The current executor has not been waited and cannot be reused");
+    }
+
+    #endregion
+
+    #region Wait
+
+    /// <summary>
+    /// 等待可重用
+    /// </summary>
+    public void Wait() => Wait(false);
+
+    /// <summary>
+    /// 等待可重用
+    /// </summary>
+    private void Wait(bool discard)
+    {
+    re:
+        var recycle_cmd_list = m_recycle_cmd_list;
+        if (recycle_cmd_list == null) return;
+        using (m_wait_lock.EnterScope())
+        {
+            if (recycle_cmd_list == m_recycle_cmd_list) goto re;
+            try
+            {
+                m_ptr->Wait().TryThrow();
+            }
+            finally
+            {
+                if (!discard)
+                {
+                    recycle_cmd_list.Reset();
+                    Queue.m_cmd_pool.Enqueue(recycle_cmd_list);
+                }
+                m_recycle_cmd_list = null;
+            }
+        }
+    }
+
+    #endregion
+}
diff --git a/Coplt.Graphics.Core/Core/GpuOutput.cs b/Coplt.Graphics.Core/Core/GpuOutput.cs
index 1d71d24..a874812 100644
--- a/Coplt.Graphics.Core/Core/GpuOutput.cs
+++ b/Coplt.Graphics.Core/Core/GpuOutput.cs
@@ -64,32 +64,49 @@ public record struct GpuOutputOptions()
 #endregion
 
 [Dropping(Unmanaged = true)]
-public sealed unsafe partial class GpuOutput : IRtv, ISrv
+public sealed unsafe partial class GpuOutput : GpuExecutor, IGpuResource, IRtv, ISrv
 {
     #region Fields
 
-    internal FGpuOutput* m_ptr;
-    internal string? m_name;
-    internal readonly GpuQueue m_queue;
+    internal new FGpuOutput* m_ptr;
 
     #endregion
 
     #region Props
 
-    public FGpuOutput* Ptr => m_ptr;
-
-    public uint3 Size => new(m_ptr->m_width, m_ptr->m_height, 1);
-    public GpuQueue Queue => m_queue;
+    public new FGpuOutput* Ptr => m_ptr;
+    public GraphicsFormat Format => m_ptr->m_format.FromFFI();
+    public ResState State
+    {
+        get => NativeState.FromFFI();
+        set => NativeState = value.ToFFI();
+    }
+    public ref FResState NativeState => ref m_ptr->m_state;
+    public uint2 Size2d => new(m_ptr->m_width, m_ptr->m_height);
+    public uint3 Size3d => new(m_ptr->m_width, m_ptr->m_height, 1);
+    ulong IGpuView.Size => m_ptr->m_width;
+    public uint Width => m_ptr->m_width;
+    public uint Height => m_ptr->m_height;
+    public uint DepthOrLength => 1;
+    public uint MipLevels => 1;
+    public uint Planes => 1;
+    uint IGpuView.Count => 0;
+    uint IGpuView.Stride => 0;
+    GpuResourceType IGpuResource.Type => GpuResourceType.Image;
+    IGpuResource IGpuView.Resource => this;
+    FResourceMeta IGpuResource.GetMeta() => new()
+    {
+        Type = FResourceRefType.Output,
+        Output = m_ptr,
+    };
 
     #endregion
 
     #region Ctor
 
-    internal GpuOutput(GpuQueue queue, FGpuOutput* ptr, string? name)
+    internal GpuOutput(FGpuOutput* ptr, string? name, GpuQueue queue) : base((FGpuExecutor*)ptr, name, queue)
     {
-        m_queue = queue;
         m_ptr = ptr;
-        m_name = name;
     }
 
     #endregion
@@ -99,32 +116,7 @@ internal GpuOutput(GpuQueue queue, FGpuOutput* ptr, string? name)
     [Drop]
     private void Drop()
     {
-        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
-        ptr->Release();
-    }
-
-    #endregion
-
-    #region SetName
-
-    public void SetName(string name)
-    {
-        m_name = name;
-        fixed (char* ptr = name)
-        {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
-            m_ptr->SetName(&str).TryThrow();
-        }
-    }
-
-    public void SetName(ReadOnlySpan<byte> name)
-    {
-        m_name = null;
-        fixed (byte* ptr = name)
-        {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
-            m_ptr->SetName(&str).TryThrow();
-        }
+        m_ptr = null;
     }
 
     #endregion
@@ -138,102 +130,16 @@ m_name is null
 
     #endregion
 
-    #region Views
-
-    FResourceMeta IView.GetMeta() => new()
-    {
-        CurrentState = m_ptr->m_state,
-        Type = FResourceRefType.Output,
-        Output = m_ptr,
-    };
-    void IView.UnsafeChangeState(FResourceState state) => UnsafeChangeState(state);
-    internal void UnsafeChangeState(FResourceState state) => m_ptr->m_state.ChangeState(state);
+    #region Present
 
-    public bool TrySrv() => true;
-    public bool TryRtv() => true;
+    public void Present(bool NoWait = false) => Queue.Submit(this, NoWait);
 
     #endregion
 
-    #region Present
-
-    /// <summary>
-    /// 提交命令并等待下帧可用
-    /// </summary>
-    public void Present()
-    {
-        using var _ = Queue.m_lock.EnterScope();
-        var cmd = Queue.m_cmd;
-        if (cmd.m_current_output != null && cmd.m_current_output != this)
-            throw new ArgumentException(
-                $"The command is already used by another output and cannot be presented in this output"
-            );
-        cmd.Present(this);
-        fixed (FResourceMeta* p_resources = CollectionsMarshal.AsSpan(cmd.m_resource_metas))
-        fixed (FCommandItem* p_commands = CollectionsMarshal.AsSpan(cmd.m_commands))
-        fixed (byte* p_payload = CollectionsMarshal.AsSpan(cmd.m_payload))
-        {
-            FCommandSubmit submit = new()
-            {
-                CommandCount = (uint)cmd.m_commands.Count,
-                ResourceCount = (uint)cmd.m_resource_metas.Count,
-                Commands = p_commands,
-                Resources = p_resources,
-                Payload = p_payload,
-            };
-            try
-            {
-                m_ptr->Present(&submit).TryThrow();
-            }
-            finally
-            {
-                cmd.Reset();
-            }
-        }
-    }
-
-    /// <summary>
-    /// 提交命令
-    /// </summary>
-    public void PresentNoWait()
-    {
-        using var _ = Queue.m_lock.EnterScope();
-        var cmd = Queue.m_cmd;
-        if (cmd.m_current_output != null && cmd.m_current_output != this)
-            throw new ArgumentException(
-                $"The command is already used by another output and cannot be presented in this output"
-            );
-        cmd.Present(this);
-        fixed (FResourceMeta* p_resources = CollectionsMarshal.AsSpan(cmd.m_resource_metas))
-        fixed (FCommandItem* p_commands = CollectionsMarshal.AsSpan(cmd.m_commands))
-        fixed (byte* p_payload = CollectionsMarshal.AsSpan(cmd.m_payload))
-        {
-            FCommandSubmit submit = new()
-            {
-                CommandCount = (uint)cmd.m_commands.Count,
-                ResourceCount = (uint)cmd.m_resource_metas.Count,
-                Commands = p_commands,
-                Resources = p_resources,
-                Payload = p_payload,
-            };
-            try
-            {
-                m_ptr->PresentNoWait(&submit).TryThrow();
-            }
-            finally
-            {
-                cmd.Reset();
-            }
-        }
-    }
+    #region Views
 
-    /// <summary>
-    /// 等待下帧可用
-    /// </summary>
-    public void WaitNextFrame()
-    {
-        using var _ = Queue.m_lock.EnterScope();
-        m_ptr->WaitNextFrame().TryThrow();
-    }
+    public bool TrySrv() => true;
+    public bool TryRtv() => true;
 
     #endregion
 
diff --git a/Coplt.Graphics.Core/Core/GpuQueue.cs b/Coplt.Graphics.Core/Core/GpuQueue.cs
index 90c1de6..fd5564c 100644
--- a/Coplt.Graphics.Core/Core/GpuQueue.cs
+++ b/Coplt.Graphics.Core/Core/GpuQueue.cs
@@ -1,4 +1,5 @@
-using Coplt.Dropping;
+using System.Collections.Concurrent;
+using Coplt.Dropping;
 using Coplt.Graphics.Native;
 
 namespace Coplt.Graphics.Core;
@@ -26,7 +27,8 @@ public sealed unsafe partial class GpuQueue
     internal string? m_name;
     internal readonly GpuDevice m_device;
     internal readonly Lock m_lock = new();
-    internal readonly CommandList m_cmd;
+    internal CommandList m_current_cmd_list;
+    internal readonly ConcurrentQueue<CommandList> m_cmd_pool = new();
 
     #endregion
 
@@ -36,7 +38,7 @@ public sealed unsafe partial class GpuQueue
     public GpuDevice Device => m_device;
     public GpuQueueType QueueType => m_ptr->m_queue_type.FromFFI();
     public SubmitId SubmitId => new(m_ptr->m_submit_id);
-    public CommandList CommandList => m_cmd;
+    public CommandList CommandList => m_current_cmd_list;
 
     #endregion
 
@@ -47,7 +49,7 @@ internal GpuQueue(FGpuQueue* ptr, string? name, GpuDevice device)
         m_name = name;
         m_ptr = ptr;
         m_device = device;
-        m_cmd = new(this);
+        m_current_cmd_list = new(this);
     }
 
     #endregion
@@ -71,19 +73,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
@@ -97,6 +99,40 @@ m_name is null
 
     #endregion
 
+    #region Submit
+
+    public void Submit(GpuExecutor Executor, bool NoWait = false)
+    {
+        using var _ = m_lock.EnterScope();
+        if (Executor is GpuOutput output)
+        {
+            if (m_current_cmd_list.m_current_output != null && m_current_cmd_list.m_current_output != output)
+                throw new ArgumentException(
+                    $"The command is already used by another output and cannot be presented in this output"
+                );
+            m_current_cmd_list.Present(output);
+        }
+        m_current_cmd_list.BuildSubmitStruct(Executor, NoWait);
+    }
+
+    internal void ActualSubmit(GpuExecutor Executor, FCommandSubmit* submit, bool NoWait)
+    {
+        if (NoWait)
+        {
+            m_ptr->SubmitNoWait(Executor.m_ptr, submit).TryThrow();
+            if (!m_cmd_pool.TryDequeue(out var new_cmd_list)) new_cmd_list = new(this);
+            Executor.SetNeedWait(m_current_cmd_list);
+            m_current_cmd_list = new_cmd_list;
+        }
+        else
+        {
+            m_ptr->Submit(Executor.m_ptr, submit).TryThrow();
+            m_current_cmd_list.Reset();
+        }
+    }
+
+    #endregion
+
     #region CreateOutputForHwnd
 
     public GpuOutput CreateOutputForHwnd(
@@ -125,7 +161,30 @@ public GpuOutput CreateOutputForHwnd(
             };
             FGpuOutput* ptr;
             m_ptr->CreateOutputForHwnd(&f_options, (void*)Hwnd, &ptr).TryThrow();
-            return new(this, ptr, Name);
+            return new(ptr, Name, this);
+        }
+    }
+
+    #endregion
+
+    #region CreateShaderBinding
+
+    public ShaderBinding CreateShaderBinding(
+        ShaderLayout Layout,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
+    )
+    {
+        fixed (char* p_name = Name)
+        fixed (byte* p_name8 = Name8)
+        {
+            FShaderBindingCreateOptions f_options = new()
+            {
+                Name = new(Name, Name8, p_name, p_name8),
+                Layout = Layout.m_ptr,
+            };
+            FShaderBinding* ptr;
+            m_device.m_ptr->CreateShaderBinding(&f_options, &ptr).TryThrow();
+            return new(ptr, Name, m_device, this, Layout);
         }
     }
 
@@ -143,12 +202,14 @@ public GpuBuffer CreateBuffer(
         {
             FGpuBufferCreateOptions f_options = new()
             {
-                Base = new()
+                Base =
                 {
-                    Name = new(Name, Name8, p_name, p_name8),
-                    Purpose = options.Purpose.ToFFI(),
+                    Base =
+                    {
+                        Name = new(Name, Name8, p_name, p_name8),
+                        Purpose = options.Purpose.ToFFI(),
+                    },
                     CpuAccess = options.CpuAccess.ToFFI(),
-                    LifeTime = options.LifeTime.ToFFI(),
                 },
                 Size = options.Size,
                 Count = options.Count,
diff --git a/Coplt.Graphics.Core/Core/GpuResource.cs b/Coplt.Graphics.Core/Core/GpuResource.cs
index 2f981d0..aa21a4f 100644
--- a/Coplt.Graphics.Core/Core/GpuResource.cs
+++ b/Coplt.Graphics.Core/Core/GpuResource.cs
@@ -5,35 +5,33 @@
 namespace Coplt.Graphics.Core;
 
 [Dropping(Unmanaged = true)]
-public abstract unsafe partial class GpuResource
+public abstract unsafe partial class GpuResource : GpuView
 {
     #region Fields
 
-    internal FGpuResource* m_ptr;
-    internal string? m_name;
-    internal GpuQueue m_queue;
+    internal new FGpuResource* m_ptr;
 
     #endregion
 
     #region Props
 
-    public FGpuResource* Ptr => m_ptr;
-    public GpuDevice Device => m_queue.m_device;
-    public GpuQueue Queue => m_queue;
-    public ResourceState State => m_ptr->m_state.FromFFI();
-    public ResourcePurpose Purpose => (ResourcePurpose)m_ptr->m_purpose;
+    public new FGpuResource* Ptr => m_ptr;
+    public ResState State
+    {
+        get => NativeState.FromFFI();
+        set => NativeState = value.ToFFI();
+    }
+    public ref FResState NativeState => ref m_ptr->m_state;
     public CpuAccess CpuAccess => (CpuAccess)m_ptr->m_cpu_access;
-    public LifeTime LifeTime => (LifeTime)m_ptr->m_life_time;
 
     #endregion
 
     #region Ctor
 
-    internal GpuResource(FGpuResource* ptr, string? name, GpuQueue queue)
+    internal GpuResource(FGpuResource* ptr, string? name, GpuQueue queue) : base(&ptr->Base, name, queue)
     {
         m_ptr = ptr;
         m_name = name;
-        m_queue = queue;
     }
 
     #endregion
@@ -43,32 +41,7 @@ internal GpuResource(FGpuResource* ptr, string? name, GpuQueue queue)
     [Drop]
     private void Drop()
     {
-        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
-        ptr->Release();
-    }
-
-    #endregion
-
-    #region SetName
-
-    public void SetName(string name)
-    {
-        m_name = name;
-        fixed (char* ptr = name)
-        {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
-            m_ptr->SetName(&str).TryThrow();
-        }
-    }
-
-    public void SetName(ReadOnlySpan<byte> name)
-    {
-        fixed (byte* ptr = name)
-        {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
-            m_ptr->SetName(&str).TryThrow();
-        }
-        m_name = null;
+        m_ptr = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/GpuView.cs b/Coplt.Graphics.Core/Core/GpuView.cs
new file mode 100644
index 0000000..54c0625
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/GpuView.cs
@@ -0,0 +1,81 @@
+using System.Runtime.CompilerServices;
+using Coplt.Dropping;
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+[Dropping(Unmanaged = true)]
+public abstract unsafe partial class GpuView
+{
+    #region Fields
+
+    internal FGpuView* m_ptr;
+    internal string? m_name;
+    internal readonly GpuQueue m_queue;
+
+    #endregion
+
+    #region Props
+
+    public FGpuView* Ptr => m_ptr;
+    public GpuDevice Device => m_queue.m_device;
+    public GpuQueue Queue => m_queue;
+    public ResourcePurpose Purpose => (ResourcePurpose)m_ptr->m_purpose;
+
+    #endregion
+
+    #region Ctor
+
+    internal GpuView(FGpuView* ptr, string? name, GpuQueue queue)
+    {
+        m_ptr = ptr;
+        m_name = name;
+        m_queue = queue;
+    }
+
+    #endregion
+
+    #region Drop
+
+    [Drop]
+    private void Drop()
+    {
+        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
+        ptr->Release();
+    }
+
+    #endregion
+
+    #region SetName
+
+    public void SetName(string name)
+    {
+        m_name = name;
+        fixed (char* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    public void SetName(ReadOnlySpan<byte> name)
+    {
+        m_name = null;
+        fixed (byte* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString() =>
+        m_name is null
+            ? $"{nameof(GpuView)}(0x{(nuint)m_ptr:X})"
+            : $"{nameof(GpuView)}(0x{(nuint)m_ptr:X} \"{m_name}\")";
+
+    #endregion
+}
diff --git a/Coplt.Graphics.Core/Core/GraphicsInstance.cs b/Coplt.Graphics.Core/Core/GraphicsInstance.cs
index fe7a4c1..5789ee2 100644
--- a/Coplt.Graphics.Core/Core/GraphicsInstance.cs
+++ b/Coplt.Graphics.Core/Core/GraphicsInstance.cs
@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Collections.Frozen;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -23,6 +24,8 @@ public unsafe partial class GraphicsInstance
     #region Fields
 
     internal FInstance* m_ptr;
+    internal readonly List<GpuAdapter> m_adapters = new();
+    internal readonly FrozenDictionary<nuint, GpuAdapter> m_ptr_to_adapters;
     internal readonly ConcurrentDictionary<string, String8> m_string_cache = new();
     internal readonly ConcurrentDictionary<string, SlotId> m_slot_id_cache = new(StringComparer.OrdinalIgnoreCase);
     internal readonly ConcurrentDictionary<SlotId, string> m_slot_id_name = new();
@@ -34,12 +37,30 @@ public unsafe partial class GraphicsInstance
     #region Props
 
     public FInstance* Ptr => m_ptr;
+    public bool DebugEnabled => m_ptr->m_debug_enabled;
+    public bool GpuBasedValidationEnabled => m_ptr->m_gpu_based_validation_enabled;
+    public ReadOnlySpan<GpuAdapter> Adapters => CollectionsMarshal.AsSpan(m_adapters);
 
     #endregion
 
     #region Ctor
 
-    public GraphicsInstance(FInstance* ptr) => m_ptr = ptr;
+    public GraphicsInstance(FInstance* ptr)
+    {
+        m_ptr = ptr;
+        uint count = 0;
+        var adapters = m_ptr->GetAdapters(&count);
+        var ptr_to_adapters = new Dictionary<nuint, GpuAdapter>();
+        for (var i = 0; i < count; i++)
+        {
+            var adapter = adapters[i];
+            adapter->AddRef();
+            var obj = new GpuAdapter(adapter, this);
+            m_adapters.Add(obj);
+            ptr_to_adapters.Add((nuint)adapter, obj);
+        }
+        m_ptr_to_adapters = ptr_to_adapters.ToFrozenDictionary();
+    }
 
     #endregion
 
@@ -56,7 +77,19 @@ private void Drop()
 
     #region Load
 
-    public static GraphicsInstance LoadD3d12() => new(D3d12Native.Coplt_Graphics_D3d12_Create_Instance());
+    public static GraphicsInstance LoadD3d12(bool Debug = false, bool GpuBasedValidation = false)
+    {
+        FInstance* ptr = default;
+        FResult r = default;
+        FInstanceCreateOptions f_options = new()
+        {
+            Debug = Debug,
+            GpuBasedValidation = GpuBasedValidation
+        };
+        D3d12Native.Coplt_Graphics_D3d12_Create_Instance(&r, &f_options, &ptr);
+        r.TryThrow();
+        return new(ptr);
+    }
 
     #endregion
 
@@ -277,30 +310,39 @@ private SlotId AllocSlotId(string name)
     #region CreateDevice
 
     public GpuDevice CreateDevice(
-        GpuDeviceOptions options = default,
-        GpuPreference Preference = GpuPreference.HighPerformance,
-        string? Name = null,
-        ReadOnlySpan<byte> Name8 = default,
-        bool Debug = false
+        DeviceRequires requires = default,
+        string? Name = null, ReadOnlySpan<byte> Name8 = default
     )
     {
-        var QueueName = !Debug || Name is null ? null : $"{Name} Main Queue";
-        var QueueName8 = !Debug || Name8.Length == 0 ? Name8 : Utils.JoinUtf8String(Name8, " Main Queue"u8);
+        var QueueName = !DebugEnabled || Name is null ? null : $"{Name} Main Queue";
+        var QueueName8 = !DebugEnabled || Name8.Length == 0 ? Name8 : Utils.JoinUtf8String(Name8, " Main Queue"u8);
 
         fixed (char* p_name = Name)
         fixed (byte* p_name8 = Name8)
         {
-            FGpuDeviceCreateOptions f_options = new()
+            FGpuAutoSelectDeviceCreateOptions f_options = new()
             {
-                Name = new(Name, Name8, p_name, p_name8),
-                D3dFeatureLevel = (FD3dFeatureLevel)options.D3dFeatureLevel,
-                VulkanVersion = (FVulkanVersion)options.VulkanVersion,
-                Preference = (FGpuPreference)Preference,
-                Debug = Debug
+                Base = { Name = new(Name, Name8, p_name, p_name8) },
+                Requires =
+                {
+                    D3dFeatureLevel = (FD3dFeatureLevel)requires.D3dFeatureLevel,
+                    VulkanVersion = (FVulkanVersion)requires.VulkanVersion,
+                    DeviceType = (FDeviceTypeRequire)requires.DeviceType,
+                    FeatureRequires =
+                    {
+                        ShaderModelLevel = (FShaderModelLevel)requires.FeatureRequires.ShaderModelLevel,
+                        RayTracing = requires.FeatureRequires.RayTracing,
+                        MeshShader = requires.FeatureRequires.MeshShader,
+                        DescriptorHeap = requires.FeatureRequires.DescriptorHeap,
+                        EnhancedBarriers = requires.FeatureRequires.EnhancedBarriers,
+                        ArrBindless = requires.FeatureRequires.ArrBindless,
+                        DynBindless = requires.FeatureRequires.DynBindless,
+                    },
+                },
             };
             FGpuDevice* ptr;
             m_ptr->CreateDevice(&f_options, &ptr).TryThrow();
-            return new(ptr, this, Name, QueueName: QueueName, QueueName8: QueueName8);
+            return new(ptr, this, null, Name, QueueName: QueueName, QueueName8: QueueName8);
         }
     }
 
diff --git a/Coplt.Graphics.Core/Core/LegacyState.cs b/Coplt.Graphics.Core/Core/LegacyState.cs
new file mode 100644
index 0000000..0d847c5
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/LegacyState.cs
@@ -0,0 +1,63 @@
+using System.Runtime.CompilerServices;
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+[Flags]
+public enum LegacyState : uint
+{
+    Manual = uint.MaxValue,
+    Common = 1 << 0,
+    Present = 1 << 1,
+    VertexBuffer = 1 << 2,
+    IndexBuffer = 1 << 3,
+    ConstantBuffer = 1 << 4,
+    IndirectBuffer = 1 << 5,
+    RenderTarget = 1 << 6,
+    DepthRead = 1 << 7,
+    DepthWrite = 1 << 8,
+    ShaderResource = 1 << 9,
+    UnorderedAccess = 1 << 10,
+    CopySrc = 1 << 11,
+    CopyDst = 1 << 12,
+    ResolveSrc = 1 << 13,
+    ResolveDst = 1 << 14,
+    RayTracing = 1 << 15,
+    ShadingRate = 1 << 16,
+    StreamOutput = 1 << 17,
+
+    GenericRead = VertexBuffer | ConstantBuffer | ShaderResource | IndirectBuffer | CopySrc,
+}
+
+public static partial class GraphicsExtensions
+{
+    public static FLegacyState ToFFI(this LegacyState value) => (FLegacyState)value;
+
+    public static LegacyState FromFFI(this FLegacyState value) => (LegacyState)value;
+
+    public static bool ContainsOnly(this LegacyState value, LegacyState other) => (value & ~other) == 0;
+    public static bool Contains(this LegacyState value, LegacyState other) => (value & other) != 0;
+
+    public static bool IsReadOnly(this LegacyState value) => value.ContainsOnly(
+        LegacyState.IndexBuffer | LegacyState.VertexBuffer | LegacyState.ConstantBuffer |
+        LegacyState.IndirectBuffer | LegacyState.CopySrc | LegacyState.ResolveSrc |
+        LegacyState.ShaderResource | LegacyState.DepthRead | LegacyState.ShadingRate
+    );
+
+    public static bool IsCompatible(this LegacyState value, LegacyState other)
+    {
+        if (value == LegacyState.Manual || other == LegacyState.Manual) return false;
+        if (value == other) return true;
+        if (value.IsReadOnly() && other.IsReadOnly()) return true;
+        return false;
+    }
+
+    public static void ChangeState(this ref LegacyState value, LegacyState state)
+    {
+        if (value.IsCompatible(state)) value |= state;
+        else value = state;
+    }
+
+    public static void ChangeState(this ref FLegacyState value, FLegacyState state) =>
+        ChangeState(ref Unsafe.As<FLegacyState, LegacyState>(ref value), (LegacyState)state);
+}
diff --git a/Coplt.Graphics.Core/Core/MeshLayout.cs b/Coplt.Graphics.Core/Core/MeshLayout.cs
index 6f2ccb0..82702e4 100644
--- a/Coplt.Graphics.Core/Core/MeshLayout.cs
+++ b/Coplt.Graphics.Core/Core/MeshLayout.cs
@@ -122,19 +122,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/ResState.cs b/Coplt.Graphics.Core/Core/ResState.cs
new file mode 100644
index 0000000..fa92068
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/ResState.cs
@@ -0,0 +1,139 @@
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+public enum ResLayout : uint
+{
+    None = 0,
+    Common,
+    Present = Common,
+    GenericRead,
+    RenderTarget,
+    UnorderedAccess,
+    DepthStencilRead,
+    DepthStencilWrite,
+    ShaderResource,
+    CopySrc,
+    CopyDst,
+    ResolveSrc,
+    ResolveDst,
+    ShadingRate,
+    VideoDecodeRead,
+    VideoDecodeWrite,
+    VideoProcessRead,
+    VideoProcessWrite,
+    VideoEncodeRead,
+    VideoEncodeWrite,
+}
+
+[Flags]
+public enum ResAccess : uint
+{
+    NoAccess = 1u << 31,
+    Common = 0,
+    ConstantBuffer = 1 << 0,
+    VertexBuffer = 1 << 1,
+    IndexBuffer = 1 << 2,
+    RenderTarget = 1 << 3,
+    UnorderedAccess = 1 << 4,
+    DepthStencilRead = 1 << 5,
+    DepthStencilWrite = 1 << 6,
+    ShaderResource = 1 << 7,
+    StreamOutput = 1 << 8,
+    IndirectOrPredicationBuffer = 1 << 9,
+    CopySrc = 1 << 10,
+    CopyDst = 1 << 11,
+    ResolveSrc = 1 << 12,
+    ResolveDst = 1 << 13,
+    RayTracingAccelerationStructureRead = 1 << 14,
+    RayTracingAccelerationStructureWrite = 1 << 15,
+    ShadingRate = 1 << 16,
+    VideoDecodeRead = 1 << 17,
+    VideoDecodeWrite = 1 << 18,
+    VideoProcessRead = 1 << 19,
+    VideoProcessWrite = 1 << 20,
+    VideoEncodeRead = 1 << 21,
+    VideoEncodeWrite = 1 << 22,
+}
+
+public record struct ResState
+{
+    public ResLayout Layout;
+    public ResAccess Access;
+    public ShaderStageFlags Stages;
+    public LegacyState Legacy;
+    public bool CrossQueue;
+}
+
+public static partial class GraphicsExtensions
+{
+    public static FResAccess ToFFI(this ResAccess value) => (FResAccess)value;
+
+    public static ResAccess FromFFI(this FResAccess value) => (ResAccess)value;
+
+    public static FResLayout ToFFI(this ResLayout value) => value switch
+    {
+        ResLayout.None              => FResLayout.None,
+        ResLayout.Common            => FResLayout.Common,
+        ResLayout.GenericRead       => FResLayout.GenericRead,
+        ResLayout.RenderTarget      => FResLayout.RenderTarget,
+        ResLayout.UnorderedAccess   => FResLayout.UnorderedAccess,
+        ResLayout.DepthStencilRead  => FResLayout.DepthStencilRead,
+        ResLayout.DepthStencilWrite => FResLayout.DepthStencilWrite,
+        ResLayout.ShaderResource    => FResLayout.ShaderResource,
+        ResLayout.CopySrc           => FResLayout.CopySrc,
+        ResLayout.CopyDst           => FResLayout.CopyDst,
+        ResLayout.ResolveSrc        => FResLayout.ResolveSrc,
+        ResLayout.ResolveDst        => FResLayout.ResolveDst,
+        ResLayout.ShadingRate       => FResLayout.ShadingRate,
+        ResLayout.VideoDecodeRead   => FResLayout.VideoDecodeRead,
+        ResLayout.VideoDecodeWrite  => FResLayout.VideoDecodeWrite,
+        ResLayout.VideoProcessRead  => FResLayout.VideoProcessRead,
+        ResLayout.VideoProcessWrite => FResLayout.VideoProcessWrite,
+        ResLayout.VideoEncodeRead   => FResLayout.VideoEncodeRead,
+        ResLayout.VideoEncodeWrite  => FResLayout.VideoEncodeWrite,
+        _                           => throw new ArgumentOutOfRangeException(nameof(value), value, null)
+    };
+
+    public static ResLayout FromFFI(this FResLayout value) => value switch
+    {
+        FResLayout.None              => ResLayout.None,
+        FResLayout.Common            => ResLayout.Common,
+        FResLayout.GenericRead       => ResLayout.GenericRead,
+        FResLayout.RenderTarget      => ResLayout.RenderTarget,
+        FResLayout.UnorderedAccess   => ResLayout.UnorderedAccess,
+        FResLayout.DepthStencilRead  => ResLayout.DepthStencilRead,
+        FResLayout.DepthStencilWrite => ResLayout.DepthStencilWrite,
+        FResLayout.ShaderResource    => ResLayout.ShaderResource,
+        FResLayout.CopySrc           => ResLayout.CopySrc,
+        FResLayout.CopyDst           => ResLayout.CopyDst,
+        FResLayout.ResolveSrc        => ResLayout.ResolveSrc,
+        FResLayout.ResolveDst        => ResLayout.ResolveDst,
+        FResLayout.ShadingRate       => ResLayout.ShadingRate,
+        FResLayout.VideoDecodeRead   => ResLayout.VideoDecodeRead,
+        FResLayout.VideoDecodeWrite  => ResLayout.VideoDecodeWrite,
+        FResLayout.VideoProcessRead  => ResLayout.VideoProcessRead,
+        FResLayout.VideoProcessWrite => ResLayout.VideoProcessWrite,
+        FResLayout.VideoEncodeRead   => ResLayout.VideoEncodeRead,
+        FResLayout.VideoEncodeWrite  => ResLayout.VideoEncodeWrite,
+        _                            => throw new ArgumentOutOfRangeException(nameof(value), value, null)
+    };
+
+    public static FResState ToFFI(this in ResState value) => new()
+    {
+        Layout = value.Layout.ToFFI(),
+        Access = value.Access.ToFFI(),
+        Stages = value.Stages.ToFFI(),
+        Legacy = value.Legacy.ToFFI(),
+        CrossQueue = value.CrossQueue,
+    };
+
+    public static ResState FromFFI(this in FResState value) => new()
+    {
+        Layout = value.Layout.FromFFI(),
+        Access = value.Access.FromFFI(),
+        Stages = value.Stages.FromFFI(),
+        Legacy = value.Legacy.FromFFI(),
+        CrossQueue = value.CrossQueue,
+    };
+}
diff --git a/Coplt.Graphics.Core/Core/ResourceEnums.cs b/Coplt.Graphics.Core/Core/ResourceEnums.cs
index 0672389..7d92d3f 100644
--- a/Coplt.Graphics.Core/Core/ResourceEnums.cs
+++ b/Coplt.Graphics.Core/Core/ResourceEnums.cs
@@ -19,22 +19,6 @@ public enum ResourcePurpose : uint
         IndirectDrawArgs = 1 << 10,
     }
 
-    public enum LifeTime : byte
-    {
-        /// <summary>
-        /// 一般资源
-        /// </summary>
-        Common,
-        /// <summary>
-        /// 静态资源，一般比如静态加载的图片、材质的参数
-        /// </summary>
-        Static,
-        /// <summary>
-        /// 瞬态资源，只在帧内使用，帧结束后将丢弃，同时每帧都会具有独立副本，类似交换链
-        /// </summary>
-        Transient,
-    }
-
     public enum CpuAccess : byte
     {
         None = 0,
@@ -66,13 +50,6 @@ public static partial class GraphicsExtensions
         public static FResourcePurpose ToFFI(this ResourcePurpose value) => (FResourcePurpose)value;
         public static bool HasFlags(this ResourcePurpose purpose, ResourcePurpose flag) => (purpose & flag) == flag;
         public static bool HasAnyFlags(this ResourcePurpose purpose, ResourcePurpose flag) => (purpose & flag) != 0;
-        public static FLifeTime ToFFI(this LifeTime value) => value switch
-        {
-            LifeTime.Common    => FLifeTime.Common,
-            LifeTime.Static    => FLifeTime.Static,
-            LifeTime.Transient => FLifeTime.Transient,
-            _                  => throw new ArgumentOutOfRangeException(nameof(value), value, null)
-        };
         public static FCpuAccess ToFFI(this CpuAccess value) => value switch
         {
             CpuAccess.None  => FCpuAccess.None,
diff --git a/Coplt.Graphics.Core/Core/ResourceState.cs b/Coplt.Graphics.Core/Core/ResourceState.cs
deleted file mode 100644
index ddae1ee..0000000
--- a/Coplt.Graphics.Core/Core/ResourceState.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-using System.Runtime.CompilerServices;
-using Coplt.Graphics.Native;
-
-namespace Coplt.Graphics.Core;
-
-[Flags]
-public enum ResourceState : uint
-{
-    Manual = uint.MaxValue,
-    Common = 1 << 0,
-    Present = 1 << 1,
-    VertexBuffer = 1 << 2,
-    IndexBuffer = 1 << 3,
-    ConstantBuffer = 1 << 4,
-    IndirectBuffer = 1 << 5,
-    RenderTarget = 1 << 6,
-    DepthRead = 1 << 7,
-    DepthWrite = 1 << 8,
-    ShaderResource = 1 << 9,
-    UnorderedAccess = 1 << 10,
-    CopySrc = 1 << 11,
-    CopyDst = 1 << 12,
-    ResolveSrc = 1 << 13,
-    ResolveDst = 1 << 14,
-    RayTracing = 1 << 15,
-    ShadingRate = 1 << 16,
-    StreamOutput = 1 << 17,
-
-    GenericRead = VertexBuffer | ConstantBuffer | ShaderResource | IndirectBuffer | CopySrc,
-}
-
-public static partial class GraphicsExtensions
-{
-    public static FResourceState ToFFI(this ResourceState value) => (FResourceState)value;
-
-    public static ResourceState FromFFI(this FResourceState value) => (ResourceState)value;
-
-    public static bool ContainsOnly(this ResourceState value, ResourceState other) => (value & ~other) == 0;
-    public static bool Contains(this ResourceState value, ResourceState other) => (value & other) != 0;
-
-    public static bool IsReadOnly(this ResourceState value) => value.ContainsOnly(
-        ResourceState.IndexBuffer | ResourceState.VertexBuffer |
-        ResourceState.ConstantBuffer | ResourceState.IndirectBuffer | ResourceState.CopySrc |
-        ResourceState.ResolveSrc | ResourceState.ShaderResource | ResourceState.DepthRead
-    );
-
-    public static bool IsCompatible(this ResourceState value, ResourceState other)
-    {
-        if (value == ResourceState.Manual || other == ResourceState.Manual) return false;
-        if (value == other) return true;
-        if (value.IsReadOnly() && other.IsReadOnly()) return true;
-        return false;
-    }
-
-    public static void ChangeState(this ref ResourceState value, ResourceState state)
-    {
-        if (value.IsCompatible(state)) value |= state;
-        else value = state;
-    }
-
-    public static void ChangeState(this ref FResourceState value, FResourceState state) =>
-        ChangeState(ref Unsafe.As<FResourceState, ResourceState>(ref value), (ResourceState)state);
-}
diff --git a/Coplt.Graphics.Core/Core/Shader.cs b/Coplt.Graphics.Core/Core/Shader.cs
index f2915b6..7980f1f 100644
--- a/Coplt.Graphics.Core/Core/Shader.cs
+++ b/Coplt.Graphics.Core/Core/Shader.cs
@@ -72,19 +72,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/ShaderBinding.cs b/Coplt.Graphics.Core/Core/ShaderBinding.cs
new file mode 100644
index 0000000..db361ac
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/ShaderBinding.cs
@@ -0,0 +1,101 @@
+using System.Buffers;
+using Coplt.Dropping;
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Core;
+
+public record struct ShaderBindingSetItem(uint Index, View View);
+
+[Dropping(Unmanaged = true)]
+public sealed unsafe partial class ShaderBinding
+{
+    #region Fields
+
+    internal FShaderBinding* m_ptr;
+    internal string? m_name;
+    internal readonly GpuDevice m_device;
+    internal readonly GpuQueue m_queue;
+    internal readonly ShaderLayout m_layout;
+    internal readonly FRoSlice<FView> m_native_views;
+    internal readonly View[] m_views;
+
+    #endregion
+
+    #region Props
+
+    public FShaderBinding* Ptr => m_ptr;
+    public GpuDevice Device => m_device;
+    public GpuQueue Queue => m_queue;
+    public ShaderLayout Layout => m_layout;
+    public ReadOnlySpan<FView> NativeViews => m_native_views.Span;
+    public ReadOnlySpan<View> Views => m_views;
+    internal Span<View> MutViews => m_views;
+    public ref readonly View this[int index] => ref m_views[index];
+
+    #endregion
+
+    #region Ctor
+
+    internal ShaderBinding(FShaderBinding* ptr, string? name, GpuDevice device, GpuQueue queue, ShaderLayout layout)
+    {
+        m_name = name;
+        m_ptr = ptr;
+        m_device = device;
+        m_queue = queue;
+        m_layout = layout;
+
+        {
+            uint size = 0;
+            var views = m_ptr->GetViews(&size);
+            m_native_views = new(views, size);
+        }
+
+        m_views = new View[m_native_views.Length];
+    }
+
+    #endregion
+
+    #region Drop
+
+    [Drop]
+    private void Drop()
+    {
+        if (ExchangeUtils.ExchangePtr(ref m_ptr, null, out var ptr) is null) return;
+        ptr->Release();
+    }
+
+    #endregion
+
+    #region SetName
+
+    public void SetName(string name)
+    {
+        m_name = name;
+        fixed (char* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    public void SetName(ReadOnlySpan<byte> name)
+    {
+        m_name = null;
+        fixed (byte* ptr = name)
+        {
+            FStr8or16 str = new(ptr, name.Length);
+            m_ptr->SetName(&str).TryThrow();
+        }
+    }
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString() =>
+        m_name is null
+            ? $"0x{nameof(ShaderBinding)}({(nuint)m_ptr:X})"
+            : $"0x{nameof(ShaderBinding)}({(nuint)m_ptr:X} \"{m_name}\")";
+
+    #endregion
+}
diff --git a/Coplt.Graphics.Core/Core/ShaderInputLayout.cs b/Coplt.Graphics.Core/Core/ShaderInputLayout.cs
index f4526f8..de6491b 100644
--- a/Coplt.Graphics.Core/Core/ShaderInputLayout.cs
+++ b/Coplt.Graphics.Core/Core/ShaderInputLayout.cs
@@ -136,19 +136,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/ShaderLayout.cs b/Coplt.Graphics.Core/Core/ShaderLayout.cs
index 50cfcc9..844a2fb 100644
--- a/Coplt.Graphics.Core/Core/ShaderLayout.cs
+++ b/Coplt.Graphics.Core/Core/ShaderLayout.cs
@@ -102,15 +102,14 @@ public sealed unsafe partial class ShaderLayout
 
     internal FShaderLayout* m_ptr;
     internal string? m_name;
-    internal readonly FShaderLayoutItemDefine* m_native_defines;
-    internal readonly uint m_native_defines_count;
+    internal readonly FRoSlice<FShaderLayoutItemDefine> m_native_defines;
 
     #endregion
 
     #region Props
 
     public FShaderLayout* Ptr => m_ptr;
-    public ReadOnlySpan<FShaderLayoutItemDefine> NativeElements => new(m_native_defines, (int)m_native_defines_count);
+    public ReadOnlySpan<FShaderLayoutItemDefine> NativeDefines => m_native_defines.Span;
 
     #endregion
 
@@ -122,9 +121,9 @@ internal ShaderLayout(FShaderLayout* ptr, string? name)
         m_name = name;
         if (m_ptr != null)
         {
-            uint count;
-            m_native_defines = m_ptr->GetItemDefines(&count);
-            m_native_defines_count = count;
+            uint count = 0;
+            var defines = m_ptr->GetItemDefines(&count);
+            m_native_defines = new(defines, count);
         }
     }
 
@@ -148,19 +147,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/ShaderModule.cs b/Coplt.Graphics.Core/Core/ShaderModule.cs
index 20fdd1a..0d931e4 100644
--- a/Coplt.Graphics.Core/Core/ShaderModule.cs
+++ b/Coplt.Graphics.Core/Core/ShaderModule.cs
@@ -52,19 +52,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/ShaderPipeline.cs b/Coplt.Graphics.Core/Core/ShaderPipeline.cs
index 4341818..31d0055 100644
--- a/Coplt.Graphics.Core/Core/ShaderPipeline.cs
+++ b/Coplt.Graphics.Core/Core/ShaderPipeline.cs
@@ -50,19 +50,19 @@ public void SetName(string name)
         m_name = name;
         fixed (char* ptr = name)
         {
-            Str8or16 str = new() { str16 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
     }
 
     public void SetName(ReadOnlySpan<byte> name)
     {
+        m_name = null;
         fixed (byte* ptr = name)
         {
-            Str8or16 str = new() { str8 = ptr, len = name.Length };
+            FStr8or16 str = new(ptr, name.Length);
             m_ptr->SetName(&str).TryThrow();
         }
-        m_name = null;
     }
 
     #endregion
diff --git a/Coplt.Graphics.Core/Core/View.cs b/Coplt.Graphics.Core/Core/View.cs
new file mode 100644
index 0000000..14b0508
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/View.cs
@@ -0,0 +1,26 @@
+using Coplt.Graphics.Native;
+using Coplt.Union;
+
+namespace Coplt.Graphics.Core;
+
+[Union]
+public unsafe partial struct View
+{
+    [UnionTemplate]
+    private interface Template
+    {
+        void None();
+        GpuBuffer Buffer();
+    }
+
+    public static View None => default;
+
+    public static implicit operator View(GpuBuffer buffer) => MakeBuffer(buffer);
+
+    public FView ToFFI() => Tag switch
+    {
+        Tags.None   => new FView { Type = FViewType.None },
+        Tags.Buffer => new FView { Type = FViewType.Buffer, Buffer = Buffer.m_ptr },
+        _           => throw new ArgumentOutOfRangeException()
+    };
+}
diff --git a/Coplt.Graphics.Core/Core/Views.cs b/Coplt.Graphics.Core/Core/Views.cs
index a7938f6..152a424 100644
--- a/Coplt.Graphics.Core/Core/Views.cs
+++ b/Coplt.Graphics.Core/Core/Views.cs
@@ -2,56 +2,116 @@
 
 namespace Coplt.Graphics.Core;
 
-public interface IView
+public interface IGpuView
 {
-    public ulong LongSize => Size.x;
-    public uint3 Size { get; }
-    public GpuQueue Queue { get; }
+    /// <summary>
+    /// 视图所属资源
+    /// </summary>
+    public IGpuResource Resource { get; }
+    /// <summary>
+    /// 资源格式
+    /// </summary>
+    public GraphicsFormat Format { get; }
+    /// <summary>
+    /// 缓冲区大小
+    /// </summary>
+    public ulong Size { get; }
+    /// <summary>
+    /// 纹理 2d 大小
+    /// </summary>
+    public uint2 Size2d => new(Width, Height);
+    /// <summary>
+    /// 纹理 3d 大小
+    /// </summary>
+    public uint3 Size3d => new(Width, Height, DepthOrLength);
+    /// <summary>
+    /// 纹理宽度
+    /// </summary>
+    public uint Width { get; }
+    /// <summary>
+    /// 纹理高度
+    /// </summary>
+    public uint Height { get; }
+    /// <summary>
+    /// 纹理深度或数组长度
+    /// </summary>
+    public uint DepthOrLength { get; }
+    /// <summary>
+    /// Mip级数量
+    /// </summary>
+    public uint MipLevels { get; }
+    /// <summary>
+    /// 平面数量
+    /// </summary>
+    public uint Planes { get; }
+    /// <summary>
+    /// 结构缓冲区中元素数量
+    /// </summary>
+    public uint Count { get; }
+    /// <summary>
+    /// 结构缓冲区中元素步幅
+    /// </summary>
+    public uint Stride { get; }
+}
 
-    public FResourceMeta GetMeta();
+public enum GpuResourceType
+{
+    Unknown,
+    Buffer,
+    Image,
+}
 
+public interface IGpuResource : IGpuView
+{
     /// <summary>
-    /// 只是用来追踪最终状态的，实际过渡不会使用
+    /// 资源所属队列
     /// </summary>
-    public void UnsafeChangeState(FResourceState state);
+    public GpuQueue Queue { get; }
+    
+    public GpuResourceType Type { get; }
+
+    public ResState State { get; set; }
+    public ref FResState NativeState { get; }
+
+    public FResourceMeta GetMeta();
 }
 
-public interface ICbv : IView
+public interface ICbv : IGpuView
 {
     public bool TryCbv();
 }
 
-public interface ISrv : IView
+public interface ISrv : IGpuView
 {
     public bool TrySrv();
 }
 
-public interface IUav : IView
+public interface IUav : IGpuView
 {
     public bool TryUav();
 }
 
-public interface IRtv : IView
+public interface IRtv : IGpuView
 {
     public bool TryRtv();
 }
 
-public interface IDsv : IView
+public interface IDsv : IGpuView
 {
     public bool TryDsv();
 }
 
-public interface IIbv : IView
+public interface IIbv : IGpuView
 {
     public bool TryIbv();
 }
 
-public interface IVbv : IView
+public interface IVbv : IGpuView
 {
     public bool TryVbv();
 }
 
-public interface ISov : IView
+public interface ISov : IGpuView
 {
     public bool TrySov();
 }
diff --git a/Coplt.Graphics.Core/Native/FResourceRef.cs b/Coplt.Graphics.Core/Native/FResourceRef.cs
index 2a57d58..0b878c7 100644
--- a/Coplt.Graphics.Core/Native/FResourceRef.cs
+++ b/Coplt.Graphics.Core/Native/FResourceRef.cs
@@ -1,6 +1,7 @@
 namespace Coplt.Graphics.Native;
 
 public partial struct FResourceRef
+    : IEquatable<FResourceRef>
 {
     public FResourceRef(uint index)
     {
@@ -10,4 +11,14 @@ public FResourceRef(int index)
     {
         ResourceIndex = (uint)index;
     }
+
+    #region Equals
+
+    public bool Equals(FResourceRef other) => ResourceIndex == other.ResourceIndex;
+    public override bool Equals(object? obj) => obj is FResourceRef other && Equals(other);
+    public override int GetHashCode() => (int)ResourceIndex;
+    public static bool operator ==(FResourceRef left, FResourceRef right) => left.Equals(right);
+    public static bool operator !=(FResourceRef left, FResourceRef right) => !left.Equals(right);
+
+    #endregion
 }
diff --git a/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs b/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs
new file mode 100644
index 0000000..1ee5c88
--- /dev/null
+++ b/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs
@@ -0,0 +1,25 @@
+using Coplt.Graphics.Core;
+
+namespace Coplt.Graphics.Native;
+
+public partial struct FShaderLayoutItemDefine
+{
+    /// <summary>
+    /// 检查兼容性，不兼容将 throw
+    /// </summary>
+    public readonly void CheckCompatible(in View view, int index)
+    {
+        switch (view.Tag)
+        {
+        case Core.View.Tags.None:
+            break;
+        case Core.View.Tags.Buffer:
+            if (Type is not (FShaderLayoutItemType.ConstantBuffer or FShaderLayoutItemType.RawBuffer
+                or FShaderLayoutItemType.StructureBuffer or FShaderLayoutItemType.StructureBufferWithCounter))
+                throw new ArgumentException($"Binding slot {index} does not supports buffers");
+            break;
+        default:
+            throw new ArgumentOutOfRangeException();
+        }
+    }
+}
diff --git a/Coplt.Graphics.Core/Native/FSlice.cs b/Coplt.Graphics.Core/Native/FSlice.cs
new file mode 100644
index 0000000..a3307c0
--- /dev/null
+++ b/Coplt.Graphics.Core/Native/FSlice.cs
@@ -0,0 +1,153 @@
+using System.Runtime.CompilerServices;
+
+namespace Coplt.Graphics.Native;
+
+public readonly unsafe struct FSlice<T>(T* Data, nuint Size) : IEquatable<FSlice<T>>
+{
+    #region Fields
+
+    public readonly T* Data = Data;
+    public readonly nuint Size = Size;
+
+    #endregion
+
+    #region Props
+
+    public bool IsEmpty => Size == 0;
+    public int Length => (int)(uint)Size;
+
+    public Span<T> Span => new(Data, Length);
+
+    public ref T this[int index] => ref Span[index];
+
+    #endregion
+
+    #region Convert
+
+    public static implicit operator Span<T>(FSlice<T> Slice) => new(Slice.Data, Slice.Length);
+
+    public static implicit operator ReadOnlySpan<T>(FSlice<T> Slice) => new(Slice.Data, Slice.Length);
+
+    public static implicit operator FRoSlice<T>(FSlice<T> Slice) => new(Slice.Data, Slice.Size);
+
+    #endregion
+
+    #region Equals
+
+    public bool Equals(FSlice<T> other) => Data == other.Data && Size == other.Size;
+    public override bool Equals(object? obj) => obj is FSlice<T> other && Equals(other);
+    public override int GetHashCode() => HashCode.Combine(unchecked((int)(long)Data), Size);
+    public static bool operator ==(FSlice<T> left, FSlice<T> right) => left.Equals(right);
+    public static bool operator !=(FSlice<T> left, FSlice<T> right) => !left.Equals(right);
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString()
+    {
+        if (typeof(T) == typeof(char)) return Span.ToString();
+        return $"FSlice<{typeof(T).Name}>(0x{(nuint)Data:X})[{Size}]";
+    }
+
+    #endregion
+
+    #region Slice
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public FSlice<T> Slice(int start)
+    {
+        ArgumentOutOfRangeException.ThrowIfGreaterThan((uint)start, (ulong)Size);
+        return new(Data + (nuint)(uint)start, Size - (uint)start);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public FSlice<T> Slice(int start, int length)
+    {
+        ArgumentOutOfRangeException.ThrowIfGreaterThan((uint)start + (uint)length, (ulong)Size);
+        return new(Data + (nuint)(uint)start, (uint)length);
+    }
+
+    #endregion
+
+    #region Enumerator
+
+    public Span<T>.Enumerator GetEnumerator() => Span.GetEnumerator();
+
+    #endregion
+}
+
+public readonly unsafe struct FRoSlice<T>(T* Data, nuint Size) : IEquatable<FRoSlice<T>>
+{
+    #region Fields
+
+    public readonly T* Data = Data;
+    public readonly nuint Size = Size;
+
+    #endregion
+
+    #region Props
+
+    public bool IsEmpty => Size == 0;
+    public int Length => (int)(uint)Size;
+
+    public ReadOnlySpan<T> Span => new(Data, Length);
+
+    public ref readonly T this[int index] => ref Span[index];
+
+    #endregion
+
+    #region Convert
+
+    public static explicit operator Span<T>(FRoSlice<T> Slice) => new(Slice.Data, Slice.Length);
+
+    public static implicit operator ReadOnlySpan<T>(FRoSlice<T> Slice) => new(Slice.Data, Slice.Length);
+
+    public static explicit operator FSlice<T>(FRoSlice<T> Slice) => new(Slice.Data, Slice.Size);
+
+    #endregion
+
+    #region Equals
+
+    public bool Equals(FRoSlice<T> other) => Data == other.Data && Size == other.Size;
+    public override bool Equals(object? obj) => obj is FRoSlice<T> other && Equals(other);
+    public override int GetHashCode() => HashCode.Combine(unchecked((int)(long)Data), Size);
+    public static bool operator ==(FRoSlice<T> left, FRoSlice<T> right) => left.Equals(right);
+    public static bool operator !=(FRoSlice<T> left, FRoSlice<T> right) => !left.Equals(right);
+
+    #endregion
+
+    #region ToString
+
+    public override string ToString()
+    {
+        if (typeof(T) == typeof(char)) return Span.ToString();
+        return $"FRoSlice<{typeof(T).Name}>(0x{(nuint)Data:X})[{Size}]";
+    }
+
+    #endregion
+
+    #region Slice
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public FRoSlice<T> Slice(int start)
+    {
+        ArgumentOutOfRangeException.ThrowIfGreaterThan((uint)start, (ulong)Size);
+        return new(Data + (nuint)(uint)start, Size - (uint)start);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public FRoSlice<T> Slice(int start, int length)
+    {
+        ArgumentOutOfRangeException.ThrowIfGreaterThan((uint)start + (uint)length, (ulong)Size);
+        return new(Data + (nuint)(uint)start, (uint)length);
+    }
+
+    #endregion
+
+    #region Enumerator
+
+    public ReadOnlySpan<T>.Enumerator GetEnumerator() => Span.GetEnumerator();
+
+    #endregion
+}
diff --git a/Coplt.Graphics.Core/Native/FUploadLoc.cs b/Coplt.Graphics.Core/Native/FUploadLoc.cs
index d288196..04c29f9 100644
--- a/Coplt.Graphics.Core/Native/FUploadLoc.cs
+++ b/Coplt.Graphics.Core/Native/FUploadLoc.cs
@@ -8,4 +8,6 @@ public FUploadLoc(in UploadLoc loc)
     {
         Index = (uint)loc.Index;
     }
+
+    public static implicit operator FUploadLoc(in UploadLoc loc) => new(loc);
 }
diff --git a/Coplt.Graphics.Core/Native/Message.cs b/Coplt.Graphics.Core/Native/Message.cs
index 1a198bd..47543dd 100644
--- a/Coplt.Graphics.Core/Native/Message.cs
+++ b/Coplt.Graphics.Core/Native/Message.cs
@@ -1,4 +1,6 @@
-using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
 using Coplt.Graphics.Utilities;
 
 namespace Coplt.Graphics.Native;
@@ -9,9 +11,9 @@ public string GetString() => msg.str == null
         ? ""
         : type switch
         {
-            FMessageType.CStr8 => Marshal.PtrToStringUTF8((nint)msg.str)!,
+            FMessageType.CStr8 => Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(msg.str)),
             FMessageType.CStr16 => new string((char*)msg.str),
-            FMessageType.Slice8 => Marshal.PtrToStringUTF8((nint)msg.str, len)!,
+            FMessageType.Slice8 => Encoding.UTF8.GetString(new ReadOnlySpan<byte>(msg.str, len)),
             FMessageType.Slice16 => new string((char*)msg.str, 0, len),
             FMessageType.String8 => new String8(msg.string8).TakeString(),
             FMessageType.String16 => new String16(msg.string16).TakeString(),
diff --git a/Coplt.Graphics.Core/Native/Native.D3d12.cs b/Coplt.Graphics.Core/Native/Native.D3d12.cs
index 74911f5..cb1eed9 100644
--- a/Coplt.Graphics.Core/Native/Native.D3d12.cs
+++ b/Coplt.Graphics.Core/Native/Native.D3d12.cs
@@ -14,6 +14,15 @@ public unsafe partial struct FD3d12Instance : INativeGuid
         public FInstance Base;
     }
 
+    [Guid("A3D7C62D-7CFD-42C1-AF7A-781170046CA5")]
+    [NativeTypeName("struct FD3d12GpuAdapter : Coplt::FGpuAdapter")]
+    public unsafe partial struct FD3d12GpuAdapter : INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FD3d12GpuAdapter));
+
+        public FGpuAdapter Base;
+    }
+
     [Guid("DB7CE2BC-155A-4FCC-9F7F-137694191CA7")]
     [NativeTypeName("struct FD3d12GpuDevice : Coplt::FGpuDevice")]
     public unsafe partial struct FD3d12GpuDevice : FD3d12GpuDevice.Interface, INativeGuid
@@ -50,16 +59,23 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, name);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FGpuAdapter *")]
+        public FGpuAdapter* GetAdapter()
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FGpuAdapter*>)(lpVtbl[5]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void* GetRawDevice()
         {
-            return ((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, void*>)(lpVtbl[5]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, void*>)(lpVtbl[6]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -67,7 +83,7 @@ public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
         public FResult CreateMainQueue([NativeTypeName("const FMainQueueCreateOptions &")] FMainQueueCreateOptions* options, FGpuQueue** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FMainQueueCreateOptions*, FGpuQueue**, FResult*>)(lpVtbl[6]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FMainQueueCreateOptions*, FGpuQueue**, FResult*>)(lpVtbl[7]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -75,7 +91,7 @@ public FResult CreateMainQueue([NativeTypeName("const FMainQueueCreateOptions &"
         public FResult CreateShaderModule([NativeTypeName("const FShaderModuleCreateOptions &")] FShaderModuleCreateOptions* options, FShaderModule** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderModuleCreateOptions*, FShaderModule**, FResult*>)(lpVtbl[7]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderModuleCreateOptions*, FShaderModule**, FResult*>)(lpVtbl[8]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -83,7 +99,15 @@ public FResult CreateShaderModule([NativeTypeName("const FShaderModuleCreateOpti
         public FResult CreateShaderLayout([NativeTypeName("const FShaderLayoutCreateOptions &")] FShaderLayoutCreateOptions* options, FShaderLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderLayoutCreateOptions*, FShaderLayout**, FResult*>)(lpVtbl[8]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderLayoutCreateOptions*, FShaderLayout**, FResult*>)(lpVtbl[9]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult GetEmptyShaderLayout([NativeTypeName("const FGetEmptyShaderLayoutOptions &")] FGetEmptyShaderLayoutOptions* options, FShaderLayout** @out)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FGetEmptyShaderLayoutOptions*, FShaderLayout**, FResult*>)(lpVtbl[10]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -91,7 +115,7 @@ public FResult CreateShaderLayout([NativeTypeName("const FShaderLayoutCreateOpti
         public FResult CreateShaderInputLayout([NativeTypeName("const FShaderInputLayoutCreateOptions &")] FShaderInputLayoutCreateOptions* options, FShaderInputLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderInputLayoutCreateOptions*, FShaderInputLayout**, FResult*>)(lpVtbl[9]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderInputLayoutCreateOptions*, FShaderInputLayout**, FResult*>)(lpVtbl[11]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -99,7 +123,15 @@ public FResult CreateShaderInputLayout([NativeTypeName("const FShaderInputLayout
         public FResult CreateShader([NativeTypeName("const FShaderCreateOptions &")] FShaderCreateOptions* options, FShader** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderCreateOptions*, FShader**, FResult*>)(lpVtbl[10]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderCreateOptions*, FShader**, FResult*>)(lpVtbl[12]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult CreateShaderBinding([NativeTypeName("const FShaderBindingCreateOptions &")] FShaderBindingCreateOptions* options, FShaderBinding** @out)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FShaderBindingCreateOptions*, FShaderBinding**, FResult*>)(lpVtbl[13]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -107,7 +139,7 @@ public FResult CreateShader([NativeTypeName("const FShaderCreateOptions &")] FSh
         public FResult CreateMeshLayout([NativeTypeName("const FMeshLayoutCreateOptions &")] FMeshLayoutCreateOptions* options, FMeshLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FMeshLayoutCreateOptions*, FMeshLayout**, FResult*>)(lpVtbl[11]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FMeshLayoutCreateOptions*, FMeshLayout**, FResult*>)(lpVtbl[14]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -115,7 +147,7 @@ public FResult CreateMeshLayout([NativeTypeName("const FMeshLayoutCreateOptions
         public FResult CreateGraphicsPipeline([NativeTypeName("const FGraphicsShaderPipelineCreateOptions &")] FGraphicsShaderPipelineCreateOptions* options, FGraphicsShaderPipeline** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FGraphicsShaderPipelineCreateOptions*, FGraphicsShaderPipeline**, FResult*>)(lpVtbl[12]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FGraphicsShaderPipelineCreateOptions*, FGraphicsShaderPipeline**, FResult*>)(lpVtbl[15]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -123,7 +155,7 @@ public FResult CreateGraphicsPipeline([NativeTypeName("const FGraphicsShaderPipe
         public FResult CreateBuffer([NativeTypeName("const FGpuBufferCreateOptions &")] FGpuBufferCreateOptions* options, FGpuBuffer** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FGpuBufferCreateOptions*, FGpuBuffer**, FResult*>)(lpVtbl[13]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuDevice*, FResult*, FGpuBufferCreateOptions*, FGpuBuffer**, FResult*>)(lpVtbl[16]))((FD3d12GpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         public interface Interface : FGpuDevice.Interface
@@ -178,50 +210,34 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, name);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetVSync([NativeTypeName("Coplt::b8")] B8 Enable)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, B8, FResult*>)(lpVtbl[5]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, Enable);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult Resize([NativeTypeName("Coplt::u32")] uint Width, [NativeTypeName("Coplt::u32")] uint Height)
+        public FResult Wait()
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, uint, uint, FResult*>)(lpVtbl[6]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, Width, Height);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, FResult*>)(lpVtbl[5]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult Present([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, FCommandSubmit*, FResult*>)(lpVtbl[7]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, submit);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult PresentNoWait([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
+        public FResult SetVSync([NativeTypeName("Coplt::b8")] B8 Enable)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, FCommandSubmit*, FResult*>)(lpVtbl[8]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, submit);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, B8, FResult*>)(lpVtbl[6]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, Enable);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult WaitNextFrame()
+        public FResult Resize([NativeTypeName("Coplt::u32")] uint Width, [NativeTypeName("Coplt::u32")] uint Height)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, FResult*>)(lpVtbl[9]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, uint, uint, FResult*>)(lpVtbl[7]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, Width, Height);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -229,7 +245,7 @@ public FResult WaitNextFrame()
         public FResult GetCurrentResourcePtr(void* @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, void*, FResult*>)(lpVtbl[10]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, void*, FResult*>)(lpVtbl[8]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -237,7 +253,7 @@ public FResult GetCurrentResourcePtr(void* @out)
         public FResult GetCurrentRtv(void* @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, void*, FResult*>)(lpVtbl[11]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, @out);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GpuOutput*, FResult*, void*, FResult*>)(lpVtbl[9]))((FD3d12GpuOutput*)Unsafe.AsPointer(ref this), &result, @out);
         }
 
         public interface Interface : FGpuOutput.Interface
@@ -297,10 +313,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -358,10 +374,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderInputLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderInputLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderInputLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderInputLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -412,10 +428,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12MeshLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12MeshLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12MeshLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12MeshLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -444,6 +460,68 @@ public interface Interface : FMeshLayout.Interface
         }
     }
 
+    [Guid("AACE0F36-A59E-45EA-88C7-7807D20D2750")]
+    [NativeTypeName("struct FD3d12ShaderBinding : Coplt::FShaderBinding")]
+    public unsafe partial struct FD3d12ShaderBinding : FD3d12ShaderBinding.Interface, INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FD3d12ShaderBinding));
+
+        public void** lpVtbl;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, void>)(lpVtbl[0]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint Release()
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, nuint>)(lpVtbl[1]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint AddRef()
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, nuint>)(lpVtbl[2]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, Guid*, void*>)(lpVtbl[3]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), &result, name);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FView *")]
+        public FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size)
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, uint*, FView*>)(lpVtbl[5]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), out_size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, FResult*, uint, FShaderBindingBatchSet*, FResult*>)(lpVtbl[6]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), &result, count, bindings);
+        }
+
+        public interface Interface : FShaderBinding.Interface
+        {
+        }
+    }
+
     [Guid("6D9C7DB7-3261-4D79-BD21-1F1BB5E01E4D")]
     [NativeTypeName("struct FD3d12PipelineState : Coplt::FShaderPipeline")]
     public unsafe partial struct FD3d12PipelineState : FD3d12PipelineState.Interface, INativeGuid
@@ -480,10 +558,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12PipelineState*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12PipelineState*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12PipelineState*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12PipelineState*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -555,10 +633,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12GraphicsShaderPipeline*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FD3d12GraphicsShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FD3d12GraphicsShaderPipeline*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12GraphicsShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -611,11 +689,12 @@ public interface Interface : FGraphicsShaderPipeline.Interface
     public static unsafe partial class D3d12Native
     {
         [DllImport("Coplt.Graphics.Native.D3d12", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("Coplt::FInstance *")]
-        public static extern FInstance* Coplt_Graphics_D3d12_Create_Instance();
+        public static extern void Coplt_Graphics_D3d12_Create_Instance([NativeTypeName("Coplt::FResult *")] FResult* r, [NativeTypeName("const Coplt::FInstanceCreateOptions &")] FInstanceCreateOptions* options, [NativeTypeName("Coplt::FInstance **")] FInstance** @out);
 
         public static readonly Guid IID_FD3d12Instance = new Guid(0x2F979FA9, 0x5CB0, 0x4396, 0xBB, 0x59, 0x16, 0x09, 0x4B, 0x0F, 0x9B, 0x1A);
 
+        public static readonly Guid IID_FD3d12GpuAdapter = new Guid(0xA3D7C62D, 0x7CFD, 0x42C1, 0xAF, 0x7A, 0x78, 0x11, 0x70, 0x04, 0x6C, 0xA5);
+
         public static readonly Guid IID_FD3d12GpuDevice = new Guid(0xDB7CE2BC, 0x155A, 0x4FCC, 0x9F, 0x7F, 0x13, 0x76, 0x94, 0x19, 0x1C, 0xA7);
 
         public static readonly Guid IID_FD3d12GpuQueue = new Guid(0x11A59DB3, 0x49D8, 0x4158, 0xA2, 0x76, 0x5D, 0x80, 0xFD, 0x37, 0xD8, 0x5F);
@@ -630,6 +709,8 @@ public static unsafe partial class D3d12Native
 
         public static readonly Guid IID_FD3d12MeshLayout = new Guid(0x2C6E52E9, 0x6FA1, 0x457A, 0x8F, 0x99, 0xA7, 0x34, 0xD6, 0x3B, 0x62, 0xC2);
 
+        public static readonly Guid IID_FD3d12ShaderBinding = new Guid(0xAACE0F36, 0xA59E, 0x45EA, 0x88, 0xC7, 0x78, 0x07, 0xD2, 0x0D, 0x27, 0x50);
+
         public static readonly Guid IID_FD3d12PipelineState = new Guid(0x6D9C7DB7, 0x3261, 0x4D79, 0xBD, 0x21, 0x1F, 0x1B, 0xB5, 0xE0, 0x1E, 0x4D);
 
         public static readonly Guid IID_FD3d12GraphicsShaderPipeline = new Guid(0xA1C6B8A9, 0x1E4C, 0x4E6C, 0x85, 0xEA, 0x2E, 0x64, 0xAC, 0x89, 0xAF, 0xC6);
diff --git a/Coplt.Graphics.Core/Native/Native.cs b/Coplt.Graphics.Core/Native/Native.cs
index 2852b1a..7d550bf 100644
--- a/Coplt.Graphics.Core/Native/Native.cs
+++ b/Coplt.Graphics.Core/Native/Native.cs
@@ -142,17 +142,17 @@ public nuint AddRef()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 GetStr()
+        [return: NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 GetStr()
         {
-            Str8or16 result;
-            return *((delegate* unmanaged[Thiscall]<FString*, Str8or16*, Str8or16*>)(lpVtbl[4]))((FString*)Unsafe.AsPointer(ref this), &result);
+            FStr8or16 result;
+            return *((delegate* unmanaged[Thiscall]<FString*, FStr8or16*, FStr8or16*>)(lpVtbl[4]))((FString*)Unsafe.AsPointer(ref this), &result);
         }
 
         public interface Interface : FUnknown.Interface
         {
-            [return: NativeTypeName("Coplt::Str8or16")]
-            Str8or16 GetStr();
+            [return: NativeTypeName("Coplt::FStr8or16")]
+            FStr8or16 GetStr();
         }
     }
 
@@ -197,11 +197,11 @@ public nuint AddRef()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 GetStr()
+        [return: NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 GetStr()
         {
-            Str8or16 result;
-            return *((delegate* unmanaged[Thiscall]<FString8*, Str8or16*, Str8or16*>)(lpVtbl[4]))((FString8*)Unsafe.AsPointer(ref this), &result);
+            FStr8or16 result;
+            return *((delegate* unmanaged[Thiscall]<FString8*, FStr8or16*, FStr8or16*>)(lpVtbl[4]))((FString8*)Unsafe.AsPointer(ref this), &result);
         }
 
         public interface Interface : FString.Interface
@@ -250,11 +250,11 @@ public nuint AddRef()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 GetStr()
+        [return: NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 GetStr()
         {
-            Str8or16 result;
-            return *((delegate* unmanaged[Thiscall]<FString16*, Str8or16*, Str8or16*>)(lpVtbl[4]))((FString16*)Unsafe.AsPointer(ref this), &result);
+            FStr8or16 result;
+            return *((delegate* unmanaged[Thiscall]<FString16*, FStr8or16*, FStr8or16*>)(lpVtbl[4]))((FString16*)Unsafe.AsPointer(ref this), &result);
         }
 
         public interface Interface : FString.Interface
@@ -313,7 +313,7 @@ public partial struct FMessage
         public FMessageType type;
     }
 
-    public unsafe partial struct Str8
+    public unsafe partial struct FStr8
     {
         [NativeTypeName("const char *")]
         public byte* str;
@@ -322,7 +322,7 @@ public unsafe partial struct Str8
         public int len;
     }
 
-    public unsafe partial struct Str16
+    public unsafe partial struct FStr16
     {
         [NativeTypeName("const Char16 *")]
         public char* str;
@@ -331,19 +331,58 @@ public unsafe partial struct Str16
         public int len;
     }
 
-    public unsafe partial struct Str8or16
+    [NativeTypeName("Coplt::u8")]
+    public enum FStrType : byte
     {
-        [NativeTypeName("const char *")]
-        public byte* str8;
+        Str16,
+        Str8,
+    }
 
-        [NativeTypeName("const Char16 *")]
-        public char* str16;
+    public unsafe partial struct FStr8or16
+    {
+        [NativeTypeName("__AnonymousRecord_String_L77_C9")]
+        public _Anonymous_e__Union Anonymous;
 
         [NativeTypeName("Coplt::i32")]
         public int len;
+
+        [NativeTypeName("Coplt::FStrType")]
+        public FStrType type;
+
+        [UnscopedRef]
+        public ref char* str16
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.str16;
+            }
+        }
+
+        [UnscopedRef]
+        public ref byte* str8
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.str8;
+            }
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public unsafe partial struct _Anonymous_e__Union
+        {
+            [FieldOffset(0)]
+            [NativeTypeName("const Char16 *")]
+            public char* str16;
+
+            [FieldOffset(0)]
+            [NativeTypeName("const char *")]
+            public byte* str8;
+        }
     }
 
-    public unsafe partial struct CStr8or16
+    public unsafe partial struct FCStr8or16
     {
         [NativeTypeName("const char *")]
         public byte* str8;
@@ -481,19 +520,27 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuObject*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGpuObject*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGpuObject*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuObject*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         public interface Interface : FUnknown.Interface
         {
             [return: NativeTypeName("Coplt::FResult")]
-            FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name);
+            FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name);
         }
     }
 
+    [NativeTypeName("Coplt::u8")]
+    public enum FBackend : byte
+    {
+        None,
+        Dx12,
+        Vulkan,
+    }
+
     [Guid("534B3C0C-098D-4157-8ADD-9B79EB5D690F")]
     [NativeTypeName("struct FAllocator : Coplt::FUnknown")]
     public unsafe partial struct FAllocator : FAllocator.Interface, INativeGuid
@@ -580,29 +627,114 @@ public interface Interface : FUnknown.Interface
         }
     }
 
-    public partial struct FGpuDeviceCreateOptions
+    public partial struct FGpuAdapter
     {
     }
 
-    public partial struct FGpuDeviceCreateOptions
+    [Guid("B3BBBED6-E997-4BD5-BE53-0AAC0CA8114D")]
+    [NativeTypeName("struct FGpuAdapter : Coplt::FUnknown")]
+    public unsafe partial struct FGpuAdapter : FGpuAdapter.Interface, INativeGuid
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuAdapter));
+
+        public void** lpVtbl;
+
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 m_name;
+
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 m_driver;
+
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 m_driver_info;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint m_vendor_id;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint m_device_id;
 
         [NativeTypeName("Coplt::FD3dFeatureLevel")]
-        public FD3dFeatureLevel D3dFeatureLevel;
+        public FD3dFeatureLevel m_d3d_feature_level;
 
         [NativeTypeName("Coplt::FVulkanVersion")]
-        public FVulkanVersion VulkanVersion;
+        public FVulkanVersion m_vulkan_version;
 
-        [NativeTypeName("Coplt::FGpuPreference")]
-        public FGpuPreference Preference;
+        [NativeTypeName("Coplt::FDeviceType")]
+        public FDeviceType m_device_type;
 
-        [NativeTypeName("Coplt::b8")]
-        public B8 Debug;
+        [NativeTypeName("Coplt::FBackend")]
+        public FBackend m_backend;
 
-        [NativeTypeName("Coplt::b8")]
-        public B8 GpuBasedValidation;
+        [NativeTypeName("Coplt::FDeviceFeatures")]
+        public FDeviceFeatures m_features;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ((delegate* unmanaged[Thiscall]<FGpuAdapter*, void>)(lpVtbl[0]))((FGpuAdapter*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint Release()
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuAdapter*, nuint>)(lpVtbl[1]))((FGpuAdapter*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint AddRef()
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuAdapter*, nuint>)(lpVtbl[2]))((FGpuAdapter*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuAdapter*, Guid*, void*>)(lpVtbl[3]))((FGpuAdapter*)Unsafe.AsPointer(ref this), id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::b8")]
+        public B8 IsSupport([NativeTypeName("const FDeviceRequires &")] FDeviceRequires* Requires)
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuAdapter*, FDeviceRequires*, B8>)(lpVtbl[4]))((FGpuAdapter*)Unsafe.AsPointer(ref this), Requires);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult CreateDevice([NativeTypeName("const FGpuDeviceCreateOptions &")] FGpuDeviceCreateOptions* options, FGpuDevice** @out)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuAdapter*, FResult*, FGpuDeviceCreateOptions*, FGpuDevice**, FResult*>)(lpVtbl[5]))((FGpuAdapter*)Unsafe.AsPointer(ref this), &result, options, @out);
+        }
+
+        public interface Interface : FUnknown.Interface
+        {
+            [return: NativeTypeName("Coplt::b8")]
+            B8 IsSupport([NativeTypeName("const FDeviceRequires &")] FDeviceRequires* Requires);
+
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult CreateDevice([NativeTypeName("const FGpuDeviceCreateOptions &")] FGpuDeviceCreateOptions* options, FGpuDevice** @out);
+        }
+    }
+
+    public partial struct FGpuAdapter
+    {
+    }
+
+    public partial struct FGpuAutoSelectDeviceCreateOptions
+    {
+    }
+
+    [NativeTypeName("struct FGpuAutoSelectDeviceCreateOptions : Coplt::FGpuDeviceCreateOptions")]
+    public partial struct FGpuAutoSelectDeviceCreateOptions
+    {
+        public FGpuDeviceCreateOptions Base;
+
+        [NativeTypeName("Coplt::FDeviceRequires")]
+        public FDeviceRequires Requires;
     }
 
     public partial struct FGpuDevice
@@ -645,16 +777,23 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, name);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FGpuAdapter *")]
+        public FGpuAdapter* GetAdapter()
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuDevice*, FGpuAdapter*>)(lpVtbl[5]))((FGpuDevice*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void* GetRawDevice()
         {
-            return ((delegate* unmanaged[Thiscall]<FGpuDevice*, void*>)(lpVtbl[5]))((FGpuDevice*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FGpuDevice*, void*>)(lpVtbl[6]))((FGpuDevice*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -662,7 +801,7 @@ public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
         public FResult CreateMainQueue([NativeTypeName("const FMainQueueCreateOptions &")] FMainQueueCreateOptions* options, FGpuQueue** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FMainQueueCreateOptions*, FGpuQueue**, FResult*>)(lpVtbl[6]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FMainQueueCreateOptions*, FGpuQueue**, FResult*>)(lpVtbl[7]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -670,7 +809,7 @@ public FResult CreateMainQueue([NativeTypeName("const FMainQueueCreateOptions &"
         public FResult CreateShaderModule([NativeTypeName("const FShaderModuleCreateOptions &")] FShaderModuleCreateOptions* options, FShaderModule** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderModuleCreateOptions*, FShaderModule**, FResult*>)(lpVtbl[7]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderModuleCreateOptions*, FShaderModule**, FResult*>)(lpVtbl[8]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -678,7 +817,15 @@ public FResult CreateShaderModule([NativeTypeName("const FShaderModuleCreateOpti
         public FResult CreateShaderLayout([NativeTypeName("const FShaderLayoutCreateOptions &")] FShaderLayoutCreateOptions* options, FShaderLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderLayoutCreateOptions*, FShaderLayout**, FResult*>)(lpVtbl[8]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderLayoutCreateOptions*, FShaderLayout**, FResult*>)(lpVtbl[9]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult GetEmptyShaderLayout([NativeTypeName("const FGetEmptyShaderLayoutOptions &")] FGetEmptyShaderLayoutOptions* options, FShaderLayout** @out)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FGetEmptyShaderLayoutOptions*, FShaderLayout**, FResult*>)(lpVtbl[10]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -686,7 +833,7 @@ public FResult CreateShaderLayout([NativeTypeName("const FShaderLayoutCreateOpti
         public FResult CreateShaderInputLayout([NativeTypeName("const FShaderInputLayoutCreateOptions &")] FShaderInputLayoutCreateOptions* options, FShaderInputLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderInputLayoutCreateOptions*, FShaderInputLayout**, FResult*>)(lpVtbl[9]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderInputLayoutCreateOptions*, FShaderInputLayout**, FResult*>)(lpVtbl[11]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -694,7 +841,15 @@ public FResult CreateShaderInputLayout([NativeTypeName("const FShaderInputLayout
         public FResult CreateShader([NativeTypeName("const FShaderCreateOptions &")] FShaderCreateOptions* options, FShader** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderCreateOptions*, FShader**, FResult*>)(lpVtbl[10]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderCreateOptions*, FShader**, FResult*>)(lpVtbl[12]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult CreateShaderBinding([NativeTypeName("const FShaderBindingCreateOptions &")] FShaderBindingCreateOptions* options, FShaderBinding** @out)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FShaderBindingCreateOptions*, FShaderBinding**, FResult*>)(lpVtbl[13]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -702,7 +857,7 @@ public FResult CreateShader([NativeTypeName("const FShaderCreateOptions &")] FSh
         public FResult CreateMeshLayout([NativeTypeName("const FMeshLayoutCreateOptions &")] FMeshLayoutCreateOptions* options, FMeshLayout** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FMeshLayoutCreateOptions*, FMeshLayout**, FResult*>)(lpVtbl[11]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FMeshLayoutCreateOptions*, FMeshLayout**, FResult*>)(lpVtbl[14]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -710,7 +865,7 @@ public FResult CreateMeshLayout([NativeTypeName("const FMeshLayoutCreateOptions
         public FResult CreateGraphicsPipeline([NativeTypeName("const FGraphicsShaderPipelineCreateOptions &")] FGraphicsShaderPipelineCreateOptions* options, FGraphicsShaderPipeline** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FGraphicsShaderPipelineCreateOptions*, FGraphicsShaderPipeline**, FResult*>)(lpVtbl[12]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FGraphicsShaderPipelineCreateOptions*, FGraphicsShaderPipeline**, FResult*>)(lpVtbl[15]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -718,11 +873,14 @@ public FResult CreateGraphicsPipeline([NativeTypeName("const FGraphicsShaderPipe
         public FResult CreateBuffer([NativeTypeName("const FGpuBufferCreateOptions &")] FGpuBufferCreateOptions* options, FGpuBuffer** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FGpuBufferCreateOptions*, FGpuBuffer**, FResult*>)(lpVtbl[13]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FGpuDevice*, FResult*, FGpuBufferCreateOptions*, FGpuBuffer**, FResult*>)(lpVtbl[16]))((FGpuDevice*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         public interface Interface : FGpuObject.Interface
         {
+            [return: NativeTypeName("Coplt::FGpuAdapter *")]
+            FGpuAdapter* GetAdapter();
+
             void* GetRawDevice();
 
             [return: NativeTypeName("Coplt::FResult")]
@@ -734,12 +892,18 @@ public interface Interface : FGpuObject.Interface
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateShaderLayout([NativeTypeName("const FShaderLayoutCreateOptions &")] FShaderLayoutCreateOptions* options, FShaderLayout** @out);
 
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult GetEmptyShaderLayout([NativeTypeName("const FGetEmptyShaderLayoutOptions &")] FGetEmptyShaderLayoutOptions* options, FShaderLayout** @out);
+
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateShaderInputLayout([NativeTypeName("const FShaderInputLayoutCreateOptions &")] FShaderInputLayoutCreateOptions* options, FShaderInputLayout** @out);
 
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateShader([NativeTypeName("const FShaderCreateOptions &")] FShaderCreateOptions* options, FShader** @out);
 
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult CreateShaderBinding([NativeTypeName("const FShaderBindingCreateOptions &")] FShaderBindingCreateOptions* options, FShaderBinding** @out);
+
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateMeshLayout([NativeTypeName("const FMeshLayoutCreateOptions &")] FMeshLayoutCreateOptions* options, FMeshLayout** @out);
 
@@ -751,6 +915,15 @@ public interface Interface : FGpuObject.Interface
         }
     }
 
+    public partial struct FInstanceCreateOptions
+    {
+        [NativeTypeName("Coplt::b8")]
+        public B8 Debug;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 GpuBasedValidation;
+    }
+
     [Guid("CC2894BA-57C7-474A-B777-1A3E3A7C922C")]
     [NativeTypeName("struct FInstance : Coplt::FUnknown")]
     public unsafe partial struct FInstance : FInstance.Interface, INativeGuid
@@ -762,6 +935,12 @@ public unsafe partial struct FInstance : FInstance.Interface, INativeGuid
         [NativeTypeName("Coplt::FAllocator *")]
         public FAllocator* m_allocator;
 
+        [NativeTypeName("Coplt::b8")]
+        public B8 m_debug_enabled;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 m_gpu_based_validation_enabled;
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose()
         {
@@ -820,12 +999,19 @@ public FResult CreateBlob([NativeTypeName("Coplt::usize")] nuint size, FBlob** @
             return *((delegate* unmanaged[Thiscall]<FInstance*, FResult*, nuint, FBlob**, FResult*>)(lpVtbl[7]))((FInstance*)Unsafe.AsPointer(ref this), &result, size, @out);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("FGpuAdapter *const *")]
+        public FGpuAdapter** GetAdapters([NativeTypeName("Coplt::u32 *")] uint* out_count)
+        {
+            return ((delegate* unmanaged[Thiscall]<FInstance*, uint*, FGpuAdapter**>)(lpVtbl[8]))((FInstance*)Unsafe.AsPointer(ref this), out_count);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult CreateDevice([NativeTypeName("const FGpuDeviceCreateOptions &")] FGpuDeviceCreateOptions* options, FGpuDevice** @out)
+        public FResult CreateDevice([NativeTypeName("const FGpuAutoSelectDeviceCreateOptions &")] FGpuAutoSelectDeviceCreateOptions* options, FGpuDevice** @out)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FInstance*, FResult*, FGpuDeviceCreateOptions*, FGpuDevice**, FResult*>)(lpVtbl[8]))((FInstance*)Unsafe.AsPointer(ref this), &result, options, @out);
+            return *((delegate* unmanaged[Thiscall]<FInstance*, FResult*, FGpuAutoSelectDeviceCreateOptions*, FGpuDevice**, FResult*>)(lpVtbl[9]))((FInstance*)Unsafe.AsPointer(ref this), &result, options, @out);
         }
 
         public interface Interface : FUnknown.Interface
@@ -842,11 +1028,79 @@ public interface Interface : FUnknown.Interface
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateBlob([NativeTypeName("Coplt::usize")] nuint size, FBlob** @out);
 
+            [return: NativeTypeName("FGpuAdapter *const *")]
+            FGpuAdapter** GetAdapters([NativeTypeName("Coplt::u32 *")] uint* out_count);
+
             [return: NativeTypeName("Coplt::FResult")]
-            FResult CreateDevice([NativeTypeName("const FGpuDeviceCreateOptions &")] FGpuDeviceCreateOptions* options, FGpuDevice** @out);
+            FResult CreateDevice([NativeTypeName("const FGpuAutoSelectDeviceCreateOptions &")] FGpuAutoSelectDeviceCreateOptions* options, FGpuDevice** @out);
         }
     }
 
+    [NativeTypeName("Coplt::u32")]
+    public enum FShaderModelLevel : uint
+    {
+        Any = 0,
+        SM_5_1 = 0x51,
+        SM_6_0 = 0x60,
+        SM_6_1 = 0x61,
+        SM_6_2 = 0x62,
+        SM_6_3 = 0x63,
+        SM_6_4 = 0x64,
+        SM_6_5 = 0x65,
+        SM_6_6 = 0x66,
+        SM_6_7 = 0x67,
+        SM_6_8 = 0x68,
+        SM_6_9 = 0x69,
+    }
+
+    public partial struct FDeviceFeatureRequires
+    {
+        [NativeTypeName("Coplt::FShaderModelLevel")]
+        public FShaderModelLevel ShaderModelLevel;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 RayTracing;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 MeshShader;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DescriptorHeap;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 EnhancedBarriers;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 ArrBindless;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DynBindless;
+    }
+
+    public partial struct FDeviceFeatures
+    {
+        [NativeTypeName("Coplt::FShaderModelLevel")]
+        public FShaderModelLevel ShaderModelLevel;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 RayTracing;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 MeshShader;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DescriptorHeap;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 EnhancedBarriers;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 ArrBindless;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DynBindless;
+    }
+
     [NativeTypeName("Coplt::i32")]
     public enum FVulkanVersion
     {
@@ -865,11 +1119,45 @@ public enum FD3dFeatureLevel
     }
 
     [NativeTypeName("Coplt::u8")]
-    public enum FGpuPreference : byte
+    public enum FDeviceTypeRequire : byte
+    {
+        Any,
+        Gpu,
+        IntegratedGpu,
+        DiscreteGpu,
+        VirtualGpu,
+        Cpu,
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FDeviceType : byte
+    {
+        Other,
+        IntegratedGpu,
+        DiscreteGpu,
+        VirtualGpu,
+        Cpu,
+    }
+
+    public partial struct FDeviceRequires
+    {
+        [NativeTypeName("Coplt::FD3dFeatureLevel")]
+        public FD3dFeatureLevel D3dFeatureLevel;
+
+        [NativeTypeName("Coplt::FVulkanVersion")]
+        public FVulkanVersion VulkanVersion;
+
+        [NativeTypeName("Coplt::FDeviceTypeRequire")]
+        public FDeviceTypeRequire DeviceType;
+
+        [NativeTypeName("Coplt::FDeviceFeatureRequires")]
+        public FDeviceFeatureRequires FeatureRequires;
+    }
+
+    public partial struct FGpuDeviceCreateOptions
     {
-        HighPerformance = 0,
-        MinimumPower = 1,
-        Any = 255,
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
     }
 
     [NativeTypeName("Coplt::u8")]
@@ -882,8 +1170,8 @@ public enum FShaderStage : byte
         Task = 4,
     }
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FShaderStageFlags : byte
+    [NativeTypeName("Coplt::u32")]
+    public enum FShaderStageFlags : uint
     {
         None = 0,
         Compute = 1 << 0,
@@ -895,8 +1183,8 @@ public enum FShaderStageFlags : byte
 
     public unsafe partial struct FShaderModuleCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FString8 *")]
         public FString8* EntryPoint;
@@ -955,10 +1243,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShaderModule*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FShaderModule*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FShaderModule*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderModule*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1018,10 +1306,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShaderLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FShaderLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FShaderLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1078,10 +1366,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShaderInputLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FShaderInputLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FShaderInputLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderInputLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1100,8 +1388,8 @@ public interface Interface : FGpuObject.Interface
 
     public unsafe partial struct FShaderCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FShaderLayout *")]
         public FShaderLayout* Layout;
@@ -1157,10 +1445,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShader*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FShader*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FShader*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShader*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1237,84 +1525,170 @@ public interface Interface : FGpuObject.Interface
         }
     }
 
-    public unsafe partial struct FUploadBufferBlock
+    public unsafe partial struct FShaderBindingCreateOptions
     {
-        [NativeTypeName("Coplt::u8 *")]
-        public byte* mapped_ptr;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
-        [NativeTypeName("Coplt::u64")]
-        public ulong cur_offset;
+        [NativeTypeName("Coplt::FShaderLayout *")]
+        public FShaderLayout* Layout;
+    }
 
-        [NativeTypeName("Coplt::u64")]
-        public ulong size;
+    public partial struct FShaderBindingBatchSet
+    {
+        [NativeTypeName("Coplt::FView")]
+        public FView View;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Index;
     }
 
-    [Guid("3A22DE68-8377-4E57-A167-3EFDB97C102A")]
-    [NativeTypeName("struct FFrameContext : Coplt::FUnknown")]
-    public unsafe partial struct FFrameContext : FFrameContext.Interface, INativeGuid
+    [Guid("A3CA644A-0E02-4D25-9A18-8835D66600F7")]
+    [NativeTypeName("struct FShaderBinding : Coplt::FGpuObject")]
+    public unsafe partial struct FShaderBinding : FShaderBinding.Interface, INativeGuid
     {
-        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FFrameContext));
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FShaderBinding));
 
         public void** lpVtbl;
 
-        public FList<FUploadBufferBlock> m_upload_buffer;
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose()
         {
-            ((delegate* unmanaged[Thiscall]<FFrameContext*, void>)(lpVtbl[0]))((FFrameContext*)Unsafe.AsPointer(ref this));
+            ((delegate* unmanaged[Thiscall]<FShaderBinding*, void>)(lpVtbl[0]))((FShaderBinding*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("size_t")]
         public nuint Release()
         {
-            return ((delegate* unmanaged[Thiscall]<FFrameContext*, nuint>)(lpVtbl[1]))((FFrameContext*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FShaderBinding*, nuint>)(lpVtbl[1]))((FShaderBinding*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("size_t")]
         public nuint AddRef()
         {
-            return ((delegate* unmanaged[Thiscall]<FFrameContext*, nuint>)(lpVtbl[2]))((FFrameContext*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FShaderBinding*, nuint>)(lpVtbl[2]))((FShaderBinding*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
         {
-            return ((delegate* unmanaged[Thiscall]<FFrameContext*, Guid*, void*>)(lpVtbl[3]))((FFrameContext*)Unsafe.AsPointer(ref this), id);
+            return ((delegate* unmanaged[Thiscall]<FShaderBinding*, Guid*, void*>)(lpVtbl[3]))((FShaderBinding*)Unsafe.AsPointer(ref this), id);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult GrowUploadBuffer([NativeTypeName("Coplt::u64")] ulong min_required_size)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FFrameContext*, FResult*, ulong, FResult*>)(lpVtbl[4]))((FFrameContext*)Unsafe.AsPointer(ref this), &result, min_required_size);
+            return *((delegate* unmanaged[Thiscall]<FShaderBinding*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderBinding*)Unsafe.AsPointer(ref this), &result, name);
         }
 
-        public interface Interface : FUnknown.Interface
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FView *")]
+        public FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size)
+        {
+            return ((delegate* unmanaged[Thiscall]<FShaderBinding*, uint*, FView*>)(lpVtbl[5]))((FShaderBinding*)Unsafe.AsPointer(ref this), out_size);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings)
         {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FShaderBinding*, FResult*, uint, FShaderBindingBatchSet*, FResult*>)(lpVtbl[6]))((FShaderBinding*)Unsafe.AsPointer(ref this), &result, count, bindings);
+        }
+
+        public interface Interface : FGpuObject.Interface
+        {
+            [return: NativeTypeName("Coplt::FView *")]
+            FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size);
+
             [return: NativeTypeName("Coplt::FResult")]
-            FResult GrowUploadBuffer([NativeTypeName("Coplt::u64")] ulong min_required_size);
+            FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings);
         }
     }
 
-    public partial struct FMainQueueCreateOptions
+    public unsafe partial struct FUploadBufferBlock
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
-    }
+        [NativeTypeName("Coplt::u8 *")]
+        public byte* mapped_ptr;
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FGpuQueueType : byte
-    {
-        Direct,
-        Compute,
-        Copy,
+        [NativeTypeName("Coplt::u64")]
+        public ulong cur_offset;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong size;
     }
 
-    [Guid("95E60E28-E387-4055-9B33-2D23AF901F8A")]
+    [Guid("3A22DE68-8377-4E57-A167-3EFDB97C102A")]
+    [NativeTypeName("struct FFrameContext : Coplt::FUnknown")]
+    public unsafe partial struct FFrameContext : FFrameContext.Interface, INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FFrameContext));
+
+        public void** lpVtbl;
+
+        public FList<FUploadBufferBlock> m_upload_buffer;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ((delegate* unmanaged[Thiscall]<FFrameContext*, void>)(lpVtbl[0]))((FFrameContext*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint Release()
+        {
+            return ((delegate* unmanaged[Thiscall]<FFrameContext*, nuint>)(lpVtbl[1]))((FFrameContext*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint AddRef()
+        {
+            return ((delegate* unmanaged[Thiscall]<FFrameContext*, nuint>)(lpVtbl[2]))((FFrameContext*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
+        {
+            return ((delegate* unmanaged[Thiscall]<FFrameContext*, Guid*, void*>)(lpVtbl[3]))((FFrameContext*)Unsafe.AsPointer(ref this), id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult GrowUploadBuffer([NativeTypeName("Coplt::u64")] ulong min_required_size)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FFrameContext*, FResult*, ulong, FResult*>)(lpVtbl[4]))((FFrameContext*)Unsafe.AsPointer(ref this), &result, min_required_size);
+        }
+
+        public interface Interface : FUnknown.Interface
+        {
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult GrowUploadBuffer([NativeTypeName("Coplt::u64")] ulong min_required_size);
+        }
+    }
+
+    public partial struct FMainQueueCreateOptions
+    {
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FGpuQueueType : byte
+    {
+        Direct,
+        Compute,
+        Copy,
+        Video,
+    }
+
+    [Guid("95E60E28-E387-4055-9B33-2D23AF901F8A")]
     [NativeTypeName("struct FGpuQueue : Coplt::FGpuObject")]
     public unsafe partial struct FGpuQueue : FGpuQueue.Interface, INativeGuid
     {
@@ -1359,10 +1733,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuQueue*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGpuQueue*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGpuQueue*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuQueue*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1387,6 +1761,22 @@ public FResult CreateOutputForHwnd([NativeTypeName("const FGpuOutputCreateOption
             return *((delegate* unmanaged[Thiscall]<FGpuQueue*, FResult*, FGpuOutputCreateOptions*, void*, FGpuOutput**, FResult*>)(lpVtbl[7]))((FGpuQueue*)Unsafe.AsPointer(ref this), &result, options, hwnd, @out);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult Submit([NativeTypeName("Coplt::FGpuExecutor *")] FGpuExecutor* Executor, [NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuQueue*, FResult*, FGpuExecutor*, FCommandSubmit*, FResult*>)(lpVtbl[8]))((FGpuQueue*)Unsafe.AsPointer(ref this), &result, Executor, submit);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult SubmitNoWait([NativeTypeName("Coplt::FGpuExecutor *")] FGpuExecutor* Executor, [NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuQueue*, FResult*, FGpuExecutor*, FCommandSubmit*, FResult*>)(lpVtbl[9]))((FGpuQueue*)Unsafe.AsPointer(ref this), &result, Executor, submit);
+        }
+
         public interface Interface : FGpuObject.Interface
         {
             void* GetRawQueue();
@@ -1396,6 +1786,69 @@ public interface Interface : FGpuObject.Interface
 
             [return: NativeTypeName("Coplt::FResult")]
             FResult CreateOutputForHwnd([NativeTypeName("const FGpuOutputCreateOptions &")] FGpuOutputCreateOptions* options, void* hwnd, FGpuOutput** @out);
+
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult Submit([NativeTypeName("Coplt::FGpuExecutor *")] FGpuExecutor* Executor, [NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit);
+
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult SubmitNoWait([NativeTypeName("Coplt::FGpuExecutor *")] FGpuExecutor* Executor, [NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit);
+        }
+    }
+
+    [Guid("EDAB0989-E0C2-4B1E-826F-C73380088FC6")]
+    [NativeTypeName("struct FGpuExecutor : Coplt::FGpuObject")]
+    public unsafe partial struct FGpuExecutor : FGpuExecutor.Interface, INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuExecutor));
+
+        public void** lpVtbl;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ((delegate* unmanaged[Thiscall]<FGpuExecutor*, void>)(lpVtbl[0]))((FGpuExecutor*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint Release()
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuExecutor*, nuint>)(lpVtbl[1]))((FGpuExecutor*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("size_t")]
+        public nuint AddRef()
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuExecutor*, nuint>)(lpVtbl[2]))((FGpuExecutor*)Unsafe.AsPointer(ref this));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
+        {
+            return ((delegate* unmanaged[Thiscall]<FGpuExecutor*, Guid*, void*>)(lpVtbl[3]))((FGpuExecutor*)Unsafe.AsPointer(ref this), id);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuExecutor*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuExecutor*)Unsafe.AsPointer(ref this), &result, name);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("Coplt::FResult")]
+        public FResult Wait()
+        {
+            FResult result;
+            return *((delegate* unmanaged[Thiscall]<FGpuExecutor*, FResult*, FResult*>)(lpVtbl[5]))((FGpuExecutor*)Unsafe.AsPointer(ref this), &result);
+        }
+
+        public interface Interface : FGpuObject.Interface
+        {
+            [return: NativeTypeName("Coplt::FResult")]
+            FResult Wait();
         }
     }
 
@@ -1430,14 +1883,6 @@ public enum FResourcePurpose : uint
         IndirectDrawArgs = 1 << 10,
     }
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FLifeTime : byte
-    {
-        Common,
-        Static,
-        Transient,
-    }
-
     [NativeTypeName("Coplt::u8")]
     public enum FCpuAccess : byte
     {
@@ -1454,73 +1899,58 @@ public enum FBufferUsage : byte
         Raw,
     }
 
-    public partial struct FGpuResourceCreateOptions
+    public partial struct FGpuViewCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FResourcePurpose")]
         public FResourcePurpose Purpose;
-
-        [NativeTypeName("Coplt::FCpuAccess")]
-        public FCpuAccess CpuAccess;
-
-        [NativeTypeName("Coplt::FLifeTime")]
-        public FLifeTime LifeTime;
     }
 
-    [Guid("F99DCEEC-2F0C-4A28-B666-BEB7C35219D6")]
-    [NativeTypeName("struct FGpuResource : Coplt::FGpuObject")]
-    public unsafe partial struct FGpuResource : FGpuResource.Interface, INativeGuid
+    [Guid("B3AEB8A5-1FA6-4866-97EF-1A5FA401E18F")]
+    [NativeTypeName("struct FGpuView : Coplt::FGpuObject")]
+    public unsafe partial struct FGpuView : FGpuView.Interface, INativeGuid
     {
-        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuResource));
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuView));
 
         public void** lpVtbl;
 
-        [NativeTypeName("Coplt::FResourceState")]
-        public FResourceState m_state;
-
         [NativeTypeName("Coplt::FResourcePurpose")]
         public FResourcePurpose m_purpose;
 
-        [NativeTypeName("Coplt::FCpuAccess")]
-        public FCpuAccess m_cpu_access;
-
-        [NativeTypeName("Coplt::FLifeTime")]
-        public FLifeTime m_life_time;
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose()
         {
-            ((delegate* unmanaged[Thiscall]<FGpuResource*, void>)(lpVtbl[0]))((FGpuResource*)Unsafe.AsPointer(ref this));
+            ((delegate* unmanaged[Thiscall]<FGpuView*, void>)(lpVtbl[0]))((FGpuView*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("size_t")]
         public nuint Release()
         {
-            return ((delegate* unmanaged[Thiscall]<FGpuResource*, nuint>)(lpVtbl[1]))((FGpuResource*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FGpuView*, nuint>)(lpVtbl[1]))((FGpuView*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("size_t")]
         public nuint AddRef()
         {
-            return ((delegate* unmanaged[Thiscall]<FGpuResource*, nuint>)(lpVtbl[2]))((FGpuResource*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FGpuView*, nuint>)(lpVtbl[2]))((FGpuView*)Unsafe.AsPointer(ref this));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void* QueryInterface([NativeTypeName("const Guid &")] Guid* id)
         {
-            return ((delegate* unmanaged[Thiscall]<FGpuResource*, Guid*, void*>)(lpVtbl[3]))((FGpuResource*)Unsafe.AsPointer(ref this), id);
+            return ((delegate* unmanaged[Thiscall]<FGpuView*, Guid*, void*>)(lpVtbl[3]))((FGpuView*)Unsafe.AsPointer(ref this), id);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuResource*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGpuResource*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGpuView*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuView*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         public interface Interface : FGpuObject.Interface
@@ -1528,6 +1958,39 @@ public interface Interface : FGpuObject.Interface
         }
     }
 
+    [NativeTypeName("struct FGpuResourceCreateOptions : Coplt::FGpuViewCreateOptions")]
+    public partial struct FGpuResourceCreateOptions
+    {
+        public FGpuViewCreateOptions Base;
+
+        [NativeTypeName("Coplt::FCpuAccess")]
+        public FCpuAccess CpuAccess;
+    }
+
+    [Guid("F99DCEEC-2F0C-4A28-B666-BEB7C35219D6")]
+    [NativeTypeName("struct FGpuResource : Coplt::FGpuView")]
+    public unsafe partial struct FGpuResource : INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuResource));
+
+        public FGpuView Base;
+
+        [NativeTypeName("Coplt::FResState")]
+        public FResState m_state;
+
+        [NativeTypeName("Coplt::FCpuAccess")]
+        public FCpuAccess m_cpu_access;
+    }
+
+    [Guid("F7DFC622-972B-49B2-8999-8FB129C61AC6")]
+    [NativeTypeName("struct FGpuTransientView : Coplt::FGpuView")]
+    public unsafe partial struct FGpuTransientView : INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuTransientView));
+
+        public FGpuView Base;
+    }
+
     [NativeTypeName("struct FGpuBufferCreateOptions : Coplt::FGpuResourceCreateOptions")]
     public partial struct FGpuBufferCreateOptions
     {
@@ -1567,6 +2030,45 @@ public unsafe partial struct FGpuBuffer : INativeGuid
         public FBufferUsage m_usage;
     }
 
+    [NativeTypeName("struct FGpuUploadBufferCreateOptions : Coplt::FGpuViewCreateOptions")]
+    public partial struct FGpuUploadBufferCreateOptions
+    {
+        public FGpuViewCreateOptions Base;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong Size;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Count;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Stride;
+
+        [NativeTypeName("Coplt::FBufferUsage")]
+        public FBufferUsage Usage;
+    }
+
+    [Guid("3E85392D-8FD3-49EB-9872-CF7A0D7C8E4C")]
+    [NativeTypeName("struct FGpuUploadBuffer : Coplt::FGpuTransientView")]
+    public unsafe partial struct FGpuUploadBuffer : INativeGuid
+    {
+        static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuUploadBuffer));
+
+        public FGpuTransientView Base;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong m_size;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint m_count;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint m_stride;
+
+        [NativeTypeName("Coplt::FBufferUsage")]
+        public FBufferUsage m_usage;
+    }
+
     [StructLayout(LayoutKind.Explicit)]
     public partial struct FOptimizedClearColor
     {
@@ -1575,7 +2077,7 @@ public partial struct FOptimizedClearColor
         public _Color_e__FixedBuffer Color;
 
         [FieldOffset(0)]
-        [NativeTypeName("__AnonymousRecord_Resource_L119_C9")]
+        [NativeTypeName("__AnonymousRecord_Resource_L143_C9")]
         public _Anonymous_e__Struct Anonymous;
 
         [UnscopedRef]
@@ -1701,6 +2203,40 @@ public unsafe partial struct FGpuImage : INativeGuid
         public FImageLayout m_layout;
     }
 
+    [NativeTypeName("Coplt::u8")]
+    public enum FViewType : byte
+    {
+        None,
+        Buffer,
+    }
+
+    public unsafe partial struct FView
+    {
+        [NativeTypeName("__AnonymousRecord_Resource_L222_C9")]
+        public _Anonymous_e__Union Anonymous;
+
+        [NativeTypeName("Coplt::FViewType")]
+        public FViewType Type;
+
+        [UnscopedRef]
+        public ref FGpuBuffer* Buffer
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Buffer;
+            }
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public unsafe partial struct _Anonymous_e__Union
+        {
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FGpuBuffer *")]
+            public FGpuBuffer* Buffer;
+        }
+    }
+
     [NativeTypeName("Coplt::u8")]
     public enum FPresentMode : byte
     {
@@ -1745,8 +2281,8 @@ public partial struct FGpuOutputFromSwapChainCreateOptions
 
     public partial struct FGpuOutputCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::u32")]
         public uint Width;
@@ -1776,32 +2312,71 @@ public partial struct FCommandSubmit
 
     public unsafe partial struct FCommandSubmit
     {
-        [NativeTypeName("Coplt::u32")]
-        public uint CommandCount;
-
-        [NativeTypeName("Coplt::u32")]
-        public uint ResourceCount;
-
         [NativeTypeName("Coplt::FCommandItem *")]
         public FCommandItem* Commands;
 
+        [NativeTypeName("Coplt::FRenderCommandItem *")]
+        public FRenderCommandItem* RenderCommands;
+
+        [NativeTypeName("Coplt::FComputeCommandItem *")]
+        public FComputeCommandItem* ComputeCommands;
+
         [NativeTypeName("Coplt::FResourceMeta *")]
         public FResourceMeta* Resources;
 
-        [NativeTypeName("Coplt::u8 *")]
-        public byte* Payload;
+        [NativeTypeName("Coplt::FRenderInfo *")]
+        public FRenderInfo* RenderInfos;
+
+        [NativeTypeName("Coplt::FComputeInfo *")]
+        public FComputeInfo* ComputeInfos;
+
+        [NativeTypeName("Coplt::FResolveInfo *")]
+        public FResolveInfo* ResolveInfos;
+
+        [NativeTypeName("Coplt::FRect *")]
+        public FRect* Rects;
+
+        [NativeTypeName("Coplt::FViewport *")]
+        public FViewport* Viewports;
+
+        [NativeTypeName("Coplt::FMeshBuffers *")]
+        public FMeshBuffers* MeshBuffers;
+
+        [NativeTypeName("Coplt::FVertexBufferRange *")]
+        public FVertexBufferRange* VertexBufferRanges;
+
+        [NativeTypeName("Coplt::FBufferCopyRange *")]
+        public FBufferCopyRange* BufferCopyRanges;
+
+        [NativeTypeName("Coplt::FBindItem *")]
+        public FBindItem* BindItems;
+
+        [NativeTypeName("Coplt::FBarrier *")]
+        public FBarrier* Barriers;
+
+        [NativeTypeName("Coplt::Char8 *")]
+        public byte* Str8;
+
+        [NativeTypeName("Coplt::Char16 *")]
+        public char* Str16;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint CommandCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ResourceCount;
     }
 
     [Guid("F1C59CB4-7EE6-4EE2-80F4-07CC568920D2")]
-    [NativeTypeName("struct FGpuOutput : Coplt::FGpuObject")]
+    [NativeTypeName("struct FGpuOutput : Coplt::FGpuExecutor")]
     public unsafe partial struct FGpuOutput : FGpuOutput.Interface, INativeGuid
     {
         static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_FGpuOutput));
 
         public void** lpVtbl;
 
-        [NativeTypeName("Coplt::FResourceState")]
-        public FResourceState m_state;
+        [NativeTypeName("Coplt::FResState")]
+        public FResState m_state;
 
         [NativeTypeName("Coplt::FGraphicsFormat")]
         public FGraphicsFormat m_format;
@@ -1840,68 +2415,43 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetVSync([NativeTypeName("Coplt::b8")] B8 Enable)
+        public FResult Wait()
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, B8, FResult*>)(lpVtbl[5]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, Enable);
+            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, FResult*>)(lpVtbl[5]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult Resize([NativeTypeName("Coplt::u32")] uint Width, [NativeTypeName("Coplt::u32")] uint Height)
+        public FResult SetVSync([NativeTypeName("Coplt::b8")] B8 Enable)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, uint, uint, FResult*>)(lpVtbl[6]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, Width, Height);
+            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, B8, FResult*>)(lpVtbl[6]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, Enable);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult Present([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
+        public FResult Resize([NativeTypeName("Coplt::u32")] uint Width, [NativeTypeName("Coplt::u32")] uint Height)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, FCommandSubmit*, FResult*>)(lpVtbl[7]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, submit);
+            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, uint, uint, FResult*>)(lpVtbl[7]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, Width, Height);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult PresentNoWait([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit)
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, FCommandSubmit*, FResult*>)(lpVtbl[8]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result, submit);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult WaitNextFrame()
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGpuOutput*, FResult*, FResult*>)(lpVtbl[9]))((FGpuOutput*)Unsafe.AsPointer(ref this), &result);
-        }
-
-        public interface Interface : FGpuObject.Interface
+        public interface Interface : FGpuExecutor.Interface
         {
             [return: NativeTypeName("Coplt::FResult")]
             FResult SetVSync([NativeTypeName("Coplt::b8")] B8 Enable);
 
             [return: NativeTypeName("Coplt::FResult")]
             FResult Resize([NativeTypeName("Coplt::u32")] uint Width, [NativeTypeName("Coplt::u32")] uint Height);
-
-            [return: NativeTypeName("Coplt::FResult")]
-            FResult Present([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit);
-
-            [return: NativeTypeName("Coplt::FResult")]
-            FResult PresentNoWait([NativeTypeName("const FCommandSubmit *")] FCommandSubmit* submit);
-
-            [return: NativeTypeName("Coplt::FResult")]
-            FResult WaitNextFrame();
         }
     }
 
@@ -2010,7 +2560,7 @@ public enum FGraphicsFormat
     }
 
     [NativeTypeName("Coplt::u32")]
-    public enum FResourceState : uint
+    public enum FLegacyState : uint
     {
         Manual = 0,
         Common = 1 << 0,
@@ -2034,28 +2584,100 @@ public enum FResourceState : uint
         GenericRead = VertexBuffer | ConstantBuffer | ShaderResource | IndirectBuffer | CopySrc,
     }
 
+    [NativeTypeName("Coplt::u32")]
+    public enum FResLayout : uint
+    {
+        None = 0,
+        Common,
+        Present = Common,
+        GenericRead,
+        RenderTarget,
+        UnorderedAccess,
+        DepthStencilRead,
+        DepthStencilWrite,
+        ShaderResource,
+        CopySrc,
+        CopyDst,
+        ResolveSrc,
+        ResolveDst,
+        ShadingRate,
+        VideoDecodeRead,
+        VideoDecodeWrite,
+        VideoProcessRead,
+        VideoProcessWrite,
+        VideoEncodeRead,
+        VideoEncodeWrite,
+    }
+
+    [NativeTypeName("Coplt::u32")]
+    public enum FResAccess : uint
+    {
+        NoAccess = 1U << 31,
+        Common = 0,
+        ConstantBuffer = 1 << 0,
+        VertexBuffer = 1 << 1,
+        IndexBuffer = 1 << 2,
+        RenderTarget = 1 << 3,
+        UnorderedAccess = 1 << 4,
+        DepthStencilRead = 1 << 5,
+        DepthStencilWrite = 1 << 6,
+        ShaderResource = 1 << 7,
+        StreamOutput = 1 << 8,
+        IndirectOrPredicationBuffer = 1 << 9,
+        CopySrc = 1 << 10,
+        CopyDst = 1 << 11,
+        ResolveSrc = 1 << 12,
+        ResolveDst = 1 << 13,
+        RayTracingAccelerationStructureRead = 1 << 14,
+        RayTracingAccelerationStructureWrite = 1 << 15,
+        ShadingRate = 1 << 16,
+        VideoDecodeRead = 1 << 17,
+        VideoDecodeWrite = 1 << 18,
+        VideoProcessRead = 1 << 19,
+        VideoProcessWrite = 1 << 20,
+        VideoEncodeRead = 1 << 21,
+        VideoEncodeWrite = 1 << 22,
+    }
+
+    public partial struct FResState
+    {
+        [NativeTypeName("Coplt::FResLayout")]
+        public FResLayout Layout;
+
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess Access;
+
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags Stages;
+
+        [NativeTypeName("Coplt::FLegacyState")]
+        public FLegacyState Legacy;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 CrossQueue;
+    }
+
     [NativeTypeName("Coplt::u32")]
     public enum FCommandType : uint
     {
         None,
-        Transition,
+        Label,
+        BeginScope,
+        EndScope,
         Present,
+        Barrier,
         ClearColor,
         ClearDepthStencil,
-        SetRenderTargets,
-        SetViewportScissor,
+        Bind,
+        BufferCopy,
+        Render,
+        Compute,
         SetPipeline,
+        SetBinding,
+        SetViewportScissor,
         SetMeshBuffers,
         Draw,
         Dispatch,
-        BufferCopy,
-    }
-
-    [NativeTypeName("Coplt::u32")]
-    public enum FCommandFlags : uint
-    {
-        None = 0,
-        DontTransition = 1 << 0,
     }
 
     [NativeTypeName("Coplt::u8")]
@@ -2068,12 +2690,9 @@ public enum FResourceRefType : byte
 
     public unsafe partial struct FResourceMeta
     {
-        [NativeTypeName("__AnonymousRecord_Command_L45_C9")]
+        [NativeTypeName("__AnonymousRecord_Command_L60_C9")]
         public _Anonymous_e__Union Anonymous;
 
-        [NativeTypeName("Coplt::FResourceState")]
-        public FResourceState CurrentState;
-
         [NativeTypeName("Coplt::FResourceRefType")]
         public FResourceRefType Type;
 
@@ -2116,210 +2735,702 @@ public partial struct FResourceRef
         public uint ResourceIndex;
     }
 
-    public partial struct FRect
+    public partial struct FSubResourceRange
     {
         [NativeTypeName("Coplt::u32")]
-        public uint left;
+        public uint IndexOrFirstMipLevel;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint NumMipLevels;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint FirstArraySlice;
 
         [NativeTypeName("Coplt::u32")]
-        public uint top;
+        public uint NumArraySlices;
 
         [NativeTypeName("Coplt::u32")]
-        public uint right;
+        public uint FirstPlane;
 
         [NativeTypeName("Coplt::u32")]
-        public uint bottom;
+        public uint NumPlanes;
     }
 
-    public partial struct FViewport
+    [NativeTypeName("Coplt::u32")]
+    public enum FImageBarrierFlags : uint
     {
-        [NativeTypeName("Coplt::f32")]
-        public float X;
+        None,
+        Discard = 1 << 0,
+        CrossQueue = 1 << 1,
+    }
 
-        [NativeTypeName("Coplt::f32")]
-        public float Y;
+    public partial struct FImageBarrier
+    {
+        [NativeTypeName("Coplt::FLegacyState")]
+        public FLegacyState LegacyBefore;
 
-        [NativeTypeName("Coplt::f32")]
-        public float Width;
+        [NativeTypeName("Coplt::FLegacyState")]
+        public FLegacyState LegacyAfter;
 
-        [NativeTypeName("Coplt::f32")]
-        public float Height;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessBefore;
 
-        [NativeTypeName("Coplt::f32")]
-        public float MinDepth;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessAfter;
 
-        [NativeTypeName("Coplt::f32")]
-        public float MaxDepth;
-    }
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesBefore;
 
-    public partial struct FCommandTransition
-    {
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Resource;
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesAfter;
 
-        [NativeTypeName("Coplt::FResourceState")]
-        public FResourceState SrcState;
+        [NativeTypeName("Coplt::FResLayout")]
+        public FResLayout LayoutBefore;
 
-        [NativeTypeName("Coplt::FResourceState")]
-        public FResourceState DstState;
-    }
+        [NativeTypeName("Coplt::FResLayout")]
+        public FResLayout LayoutAfter;
 
-    public partial struct FCommandPresent
-    {
         [NativeTypeName("Coplt::FResourceRef")]
         public FResourceRef Image;
+
+        [NativeTypeName("Coplt::FSubResourceRange")]
+        public FSubResourceRange SubResourceRange;
+
+        [NativeTypeName("Coplt::FImageBarrierFlags")]
+        public FImageBarrierFlags Flags;
     }
 
-    public partial struct FCommandClearColor
+    public partial struct FBufferBarrier
     {
-        [NativeTypeName("Coplt::u32")]
-        public uint RectCount;
+        [NativeTypeName("Coplt::FLegacyState")]
+        public FLegacyState LegacyBefore;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint RectIndex;
+        [NativeTypeName("Coplt::FLegacyState")]
+        public FLegacyState LegacyAfter;
 
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Image;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessBefore;
 
-        [NativeTypeName("f32[4]")]
-        public _Color_e__FixedBuffer Color;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessAfter;
 
-        [InlineArray(4)]
-        public partial struct _Color_e__FixedBuffer
-        {
-            public float e0;
-        }
-    }
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesBefore;
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FDepthStencilClearFlags : byte
-    {
-        None = 0,
-        Depth = 1,
-        Stencil = 2,
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesAfter;
+
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Buffer;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong Offset;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong Size;
     }
 
-    public partial struct FCommandClearDepthStencil
+    public partial struct FGlobalBarrier
     {
-        [NativeTypeName("Coplt::u32")]
-        public uint RectCount;
-
-        [NativeTypeName("Coplt::u32")]
-        public uint RectIndex;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessBefore;
 
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Image;
+        [NativeTypeName("Coplt::FResAccess")]
+        public FResAccess AccessAfter;
 
-        [NativeTypeName("Coplt::f32")]
-        public float Depth;
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesBefore;
 
-        [NativeTypeName("Coplt::u8")]
-        public byte Stencil;
+        [NativeTypeName("Coplt::FShaderStageFlags")]
+        public FShaderStageFlags StagesAfter;
+    }
 
-        [NativeTypeName("Coplt::FDepthStencilClearFlags")]
-        public FDepthStencilClearFlags Clear;
+    [NativeTypeName("Coplt::u8")]
+    public enum FBarrierType : byte
+    {
+        None,
+        Global,
+        Buffer,
+        Image,
     }
 
-    public partial struct FCommandSetRenderTargets
+    public partial struct FBarrier
     {
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Dsv;
+        [NativeTypeName("Coplt::FBarrierType")]
+        public FBarrierType Type;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint NumRtv;
+        [NativeTypeName("__AnonymousRecord_Command_L166_C9")]
+        public _Anonymous_e__Union Anonymous;
 
-        [NativeTypeName("FResourceRef[8]")]
-        public _Rtv_e__FixedBuffer Rtv;
+        [UnscopedRef]
+        public ref FGlobalBarrier Global
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Global;
+            }
+        }
 
-        [NativeTypeName("Coplt::u32")]
-        public uint ViewportCount;
+        [UnscopedRef]
+        public ref FBufferBarrier Buffer
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Buffer;
+            }
+        }
 
-        [NativeTypeName("Coplt::u32")]
-        public uint ViewportIndex;
+        [UnscopedRef]
+        public ref FImageBarrier Image
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Image;
+            }
+        }
 
-        [NativeTypeName("Coplt::u32")]
-        public uint ScissorRectCount;
+        [StructLayout(LayoutKind.Explicit)]
+        public partial struct _Anonymous_e__Union
+        {
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FGlobalBarrier")]
+            public FGlobalBarrier Global;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint ScissorRectIndex;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FBufferBarrier")]
+            public FBufferBarrier Buffer;
 
-        [InlineArray(8)]
-        public partial struct _Rtv_e__FixedBuffer
-        {
-            public FResourceRef e0;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FImageBarrier")]
+            public FImageBarrier Image;
         }
     }
 
-    public partial struct FCommandSetViewportScissor
+    public partial struct FRect
     {
         [NativeTypeName("Coplt::u32")]
-        public uint ViewportCount;
+        public uint Left;
 
         [NativeTypeName("Coplt::u32")]
-        public uint ViewportIndex;
+        public uint Top;
 
         [NativeTypeName("Coplt::u32")]
-        public uint ScissorRectCount;
+        public uint Right;
 
         [NativeTypeName("Coplt::u32")]
-        public uint ScissorRectIndex;
+        public uint Bottom;
     }
 
-    public unsafe partial struct FCommandSetPipeline
+    public partial struct FViewport
     {
-        [NativeTypeName("Coplt::FShaderPipeline *")]
-        public FShaderPipeline* Pipeline;
-    }
+        [NativeTypeName("Coplt::f32")]
+        public float X;
 
-    public partial struct FBufferRange
-    {
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Buffer;
+        [NativeTypeName("Coplt::f32")]
+        public float Y;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint Offset;
+        [NativeTypeName("Coplt::f32")]
+        public float Width;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint Size;
-    }
+        [NativeTypeName("Coplt::f32")]
+        public float Height;
 
-    [NativeTypeName("struct FVertexBufferRange : Coplt::FBufferRange")]
-    public partial struct FVertexBufferRange
-    {
-        public FBufferRange Base;
+        [NativeTypeName("Coplt::f32")]
+        public float MinDepth;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint Index;
+        [NativeTypeName("Coplt::f32")]
+        public float MaxDepth;
     }
 
-    public unsafe partial struct FCommandSetMeshBuffers
+    [NativeTypeName("Coplt::u8")]
+    public enum FDepthStencilClearFlags : byte
     {
-        [NativeTypeName("Coplt::FMeshLayout *")]
-        public FMeshLayout* MeshLayout;
-
-        [NativeTypeName("Coplt::FGraphicsFormat")]
-        public FGraphicsFormat IndexFormat;
+        None = 0,
+        Depth = 1,
+        Stencil = 2,
+    }
 
-        [NativeTypeName("Coplt::FBufferRange")]
-        public FBufferRange IndexBuffer;
+    public partial struct FBindItem
+    {
+        [NativeTypeName("Coplt::FCommandType")]
+        public FCommandType Type;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint VertexStartSlot;
+        [NativeTypeName("Coplt::FView")]
+        public FView View;
 
         [NativeTypeName("Coplt::u32")]
-        public uint VertexBufferCount;
+        public uint Index;
+    }
 
+    public partial struct FUploadLoc
+    {
         [NativeTypeName("Coplt::u32")]
-        public uint VertexBuffersIndex;
+        public uint Index;
     }
 
-    public unsafe partial struct FCommandDraw
+    [StructLayout(LayoutKind.Explicit)]
+    public partial struct FBufferRef
     {
-        [NativeTypeName("Coplt::FShaderPipeline *")]
-        public FShaderPipeline* Pipeline;
+        [FieldOffset(0)]
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Buffer;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint VertexOrIndexCount;
+        [FieldOffset(0)]
+        [NativeTypeName("Coplt::FUploadLoc")]
+        public FUploadLoc Upload;
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FBufferRefType : byte
+    {
+        Buffer = 0,
+        Upload,
+    }
+
+    public partial struct FBufferCopyRange
+    {
+        [NativeTypeName("Coplt::u64")]
+        public ulong Size;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong DstOffset;
+
+        [NativeTypeName("Coplt::u64")]
+        public ulong SrcOffset;
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FResolveMode : byte
+    {
+        Decompress,
+        Min,
+        Max,
+        Average,
+    }
+
+    public partial struct FResolveInfo
+    {
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Src;
+
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Dst;
+
+        [NativeTypeName("Coplt::FGraphicsFormat")]
+        public FGraphicsFormat Format;
+
+        [NativeTypeName("Coplt::FResolveMode")]
+        public FResolveMode Mode;
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FLoadOp : byte
+    {
+        Load,
+        Clear,
+        Discard,
+        NoAccess,
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FStoreOp : byte
+    {
+        Store,
+        Discard,
+        Resolve,
+        NoAccess,
+    }
+
+    public partial struct FRenderInfo
+    {
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Dsv;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint NumRtv;
+
+        [NativeTypeName("FResourceRef[8]")]
+        public _Rtv_e__FixedBuffer Rtv;
+
+        [NativeTypeName("u32[8]")]
+        public _ResolveInfoIndex_e__FixedBuffer ResolveInfoIndex;
+
+        [NativeTypeName("f32[32]")]
+        public _Color_e__FixedBuffer Color;
+
+        [NativeTypeName("Coplt::f32")]
+        public float Depth;
+
+        [NativeTypeName("Coplt::u8")]
+        public byte Stencil;
+
+        [NativeTypeName("FLoadOp[2]")]
+        public _DsvLoadOp_e__FixedBuffer DsvLoadOp;
+
+        [NativeTypeName("FStoreOp[2]")]
+        public _DsvStoreOp_e__FixedBuffer DsvStoreOp;
+
+        [NativeTypeName("FLoadOp[8]")]
+        public _RtvLoadOp_e__FixedBuffer RtvLoadOp;
+
+        [NativeTypeName("FStoreOp[8]")]
+        public _RtvStoreOp_e__FixedBuffer RtvStoreOp;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 HasUavWrites;
+
+        [InlineArray(8)]
+        public partial struct _Rtv_e__FixedBuffer
+        {
+            public FResourceRef e0;
+        }
+
+        [InlineArray(8)]
+        public partial struct _ResolveInfoIndex_e__FixedBuffer
+        {
+            public uint e0;
+        }
+
+        [InlineArray(32)]
+        public partial struct _Color_e__FixedBuffer
+        {
+            public float e0;
+        }
+
+        [InlineArray(2)]
+        public partial struct _DsvLoadOp_e__FixedBuffer
+        {
+            public FLoadOp e0;
+        }
+
+        [InlineArray(2)]
+        public partial struct _DsvStoreOp_e__FixedBuffer
+        {
+            public FStoreOp e0;
+        }
+
+        [InlineArray(8)]
+        public partial struct _RtvLoadOp_e__FixedBuffer
+        {
+            public FLoadOp e0;
+        }
+
+        [InlineArray(8)]
+        public partial struct _RtvStoreOp_e__FixedBuffer
+        {
+            public FStoreOp e0;
+        }
+    }
+
+    public partial struct FComputeInfo
+    {
+    }
+
+    public partial struct FBufferRange
+    {
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Buffer;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Offset;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Size;
+    }
+
+    [NativeTypeName("struct FVertexBufferRange : Coplt::FBufferRange")]
+    public partial struct FVertexBufferRange
+    {
+        public FBufferRange Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Index;
+    }
+
+    public unsafe partial struct FMeshBuffers
+    {
+        [NativeTypeName("Coplt::FMeshLayout *")]
+        public FMeshLayout* MeshLayout;
+
+        [NativeTypeName("Coplt::FBufferRange")]
+        public FBufferRange IndexBuffer;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint VertexBufferCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint VertexBuffersIndex;
+    }
+
+    [NativeTypeName("Coplt::u8")]
+    public enum FDispatchType : byte
+    {
+        Compute,
+        Mesh,
+    }
+
+    public partial struct FCommandBase
+    {
+        [NativeTypeName("Coplt::FCommandType")]
+        public FCommandType Type;
+    }
+
+    [NativeTypeName("struct FCommandLabel : Coplt::FCommandBase")]
+    public partial struct FCommandLabel
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint StringIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint StringLength;
+
+        [NativeTypeName("Coplt::FStrType")]
+        public FStrType StrType;
+
+        [NativeTypeName("u8[3]")]
+        public _Color_e__FixedBuffer Color;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 HasColor;
+
+        [InlineArray(3)]
+        public partial struct _Color_e__FixedBuffer
+        {
+            public byte e0;
+        }
+    }
+
+    [NativeTypeName("struct FCommandBeginScope : Coplt::FCommandBase")]
+    public partial struct FCommandBeginScope
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint StringIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint StringLength;
+
+        [NativeTypeName("Coplt::FStrType")]
+        public FStrType StrType;
+
+        [NativeTypeName("u8[3]")]
+        public _Color_e__FixedBuffer Color;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 HasColor;
+
+        [InlineArray(3)]
+        public partial struct _Color_e__FixedBuffer
+        {
+            public byte e0;
+        }
+    }
+
+    [NativeTypeName("struct FCommandEndScope : Coplt::FCommandBase")]
+    public partial struct FCommandEndScope
+    {
+        public FCommandBase Base;
+    }
+
+    [NativeTypeName("struct FCommandPresent : Coplt::FCommandBase")]
+    public partial struct FCommandPresent
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Image;
+    }
+
+    [NativeTypeName("struct FCommandBarrier : Coplt::FCommandBase")]
+    public partial struct FCommandBarrier
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint BarrierIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint BarrierCount;
+    }
+
+    [NativeTypeName("struct FCommandClearColor : Coplt::FCommandBase")]
+    public partial struct FCommandClearColor
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint RectCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint RectIndex;
+
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Image;
+
+        [NativeTypeName("f32[4]")]
+        public _Color_e__FixedBuffer Color;
+
+        [InlineArray(4)]
+        public partial struct _Color_e__FixedBuffer
+        {
+            public float e0;
+        }
+    }
+
+    [NativeTypeName("struct FCommandClearDepthStencil : Coplt::FCommandBase")]
+    public partial struct FCommandClearDepthStencil
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint RectCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint RectIndex;
+
+        [NativeTypeName("Coplt::FResourceRef")]
+        public FResourceRef Image;
+
+        [NativeTypeName("Coplt::f32")]
+        public float Depth;
+
+        [NativeTypeName("Coplt::u8")]
+        public byte Stencil;
+
+        [NativeTypeName("Coplt::FDepthStencilClearFlags")]
+        public FDepthStencilClearFlags Clear;
+    }
+
+    [NativeTypeName("struct FCommandBind : Coplt::FCommandBase")]
+    public unsafe partial struct FCommandBind
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ItemCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ItemsIndex;
+
+        [NativeTypeName("Coplt::FShaderBinding *")]
+        public FShaderBinding* Binding;
+    }
+
+    [NativeTypeName("struct FCommandBufferCopy : Coplt::FCommandBase")]
+    public partial struct FCommandBufferCopy
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint RangeIndex;
+
+        [NativeTypeName("Coplt::FBufferRef")]
+        public FBufferRef Dst;
+
+        [NativeTypeName("Coplt::FBufferRef")]
+        public FBufferRef Src;
+
+        [NativeTypeName("Coplt::FBufferRefType")]
+        public FBufferRefType DstType;
+
+        [NativeTypeName("Coplt::FBufferRefType")]
+        public FBufferRefType SrcType;
+    }
+
+    [NativeTypeName("struct FCommandRender : Coplt::FCommandBase")]
+    public partial struct FCommandRender
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint InfoIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint CommandStartIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint CommandCount;
+    }
+
+    [NativeTypeName("struct FCommandCompute : Coplt::FCommandBase")]
+    public partial struct FCommandCompute
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint InfoIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint CommandStartIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint CommandCount;
+    }
+
+    [NativeTypeName("struct FCommandSetPipeline : Coplt::FCommandBase")]
+    public unsafe partial struct FCommandSetPipeline
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::FShaderPipeline *")]
+        public FShaderPipeline* Pipeline;
+    }
+
+    [NativeTypeName("struct FCommandSetBinding : Coplt::FCommandBase")]
+    public unsafe partial struct FCommandSetBinding
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::FShaderBinding *")]
+        public FShaderBinding* Binding;
+    }
+
+    [NativeTypeName("struct FCommandSetViewportScissor : Coplt::FCommandBase")]
+    public partial struct FCommandSetViewportScissor
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ViewportCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ViewportIndex;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ScissorRectCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint ScissorRectIndex;
+    }
+
+    [NativeTypeName("struct FCommandSetMeshBuffers : Coplt::FCommandBase")]
+    public partial struct FCommandSetMeshBuffers
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::FGraphicsFormat")]
+        public FGraphicsFormat IndexFormat;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint VertexStartSlot;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint PayloadIndex;
+    }
+
+    [NativeTypeName("struct FCommandDraw : Coplt::FCommandBase")]
+    public partial struct FCommandDraw
+    {
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint VertexOrIndexCount;
 
         [NativeTypeName("Coplt::u32")]
         public uint InstanceCount;
@@ -2337,158 +3448,294 @@ public unsafe partial struct FCommandDraw
         public B8 Indexed;
     }
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FDispatchType : byte
+    [NativeTypeName("struct FCommandDispatch : Coplt::FCommandBase")]
+    public partial struct FCommandDispatch
     {
-        Compute,
-        Mesh,
+        public FCommandBase Base;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint GroupCountX;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint GroupCountY;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint GroupCountZ;
+
+        [NativeTypeName("Coplt::FDispatchType")]
+        public FDispatchType Type;
     }
 
-    public unsafe partial struct FCommandDispatch
-    {
-        [NativeTypeName("Coplt::FShaderPipeline *")]
-        public FShaderPipeline* Pipeline;
+    public partial struct FCommandItem
+    {
+        [NativeTypeName("__AnonymousRecord_Command_L489_C9")]
+        public _Anonymous_e__Union Anonymous;
+
+        [UnscopedRef]
+        public ref FCommandType Type
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Type;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandLabel Label
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Label;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandBeginScope BeginScope
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.BeginScope;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandEndScope EndScope
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.EndScope;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandPresent Present
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Present;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandBarrier Barrier
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Barrier;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandClearColor ClearColor
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.ClearColor;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandClearDepthStencil ClearDepthStencil
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.ClearDepthStencil;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandBind Bind
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Bind;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandBufferCopy BufferCopy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.BufferCopy;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandRender Render
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Render;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandCompute Compute
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Compute;
+            }
+        }
 
-        [NativeTypeName("Coplt::u32")]
-        public uint GroupCountX;
+        [UnscopedRef]
+        public Span<byte> _pad
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return Anonymous._pad;
+            }
+        }
 
-        [NativeTypeName("Coplt::u32")]
-        public uint GroupCountY;
+        [StructLayout(LayoutKind.Explicit)]
+        public partial struct _Anonymous_e__Union
+        {
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandType")]
+            public FCommandType Type;
 
-        [NativeTypeName("Coplt::u32")]
-        public uint GroupCountZ;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandLabel")]
+            public FCommandLabel Label;
 
-        [NativeTypeName("Coplt::FDispatchType")]
-        public FDispatchType Type;
-    }
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandBeginScope")]
+            public FCommandBeginScope BeginScope;
 
-    public partial struct FUploadLoc
-    {
-        [NativeTypeName("Coplt::u32")]
-        public uint Index;
-    }
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandEndScope")]
+            public FCommandEndScope EndScope;
 
-    [StructLayout(LayoutKind.Explicit)]
-    public partial struct FBufferRef
-    {
-        [FieldOffset(0)]
-        [NativeTypeName("Coplt::FResourceRef")]
-        public FResourceRef Buffer;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandPresent")]
+            public FCommandPresent Present;
 
-        [FieldOffset(0)]
-        [NativeTypeName("Coplt::FUploadLoc")]
-        public FUploadLoc Upload;
-    }
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandBarrier")]
+            public FCommandBarrier Barrier;
 
-    [NativeTypeName("Coplt::u8")]
-    public enum FBufferRefType : byte
-    {
-        Buffer = 0,
-        Upload,
-    }
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandClearColor")]
+            public FCommandClearColor ClearColor;
 
-    public partial struct FCommandBufferCopy
-    {
-        [NativeTypeName("Coplt::u64")]
-        public ulong Size;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandClearDepthStencil")]
+            public FCommandClearDepthStencil ClearDepthStencil;
 
-        [NativeTypeName("Coplt::u64")]
-        public ulong DstOffset;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandBind")]
+            public FCommandBind Bind;
 
-        [NativeTypeName("Coplt::u64")]
-        public ulong SrcOffset;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandBufferCopy")]
+            public FCommandBufferCopy BufferCopy;
 
-        [NativeTypeName("Coplt::FBufferRef")]
-        public FBufferRef Dst;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandRender")]
+            public FCommandRender Render;
 
-        [NativeTypeName("Coplt::FBufferRef")]
-        public FBufferRef Src;
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandCompute")]
+            public FCommandCompute Compute;
 
-        [NativeTypeName("Coplt::FBufferRefType")]
-        public FBufferRefType DstType;
+            [FieldOffset(0)]
+            [NativeTypeName("u8[32]")]
+            public __pad_e__FixedBuffer _pad;
 
-        [NativeTypeName("Coplt::FBufferRefType")]
-        public FBufferRefType SrcType;
+            [InlineArray(32)]
+            public partial struct __pad_e__FixedBuffer
+            {
+                public byte e0;
+            }
+        }
     }
 
-    public partial struct FCommandItem
+    public partial struct FRenderCommandItem
     {
-        [NativeTypeName("Coplt::FCommandType")]
-        public FCommandType Type;
-
-        [NativeTypeName("Coplt::FCommandFlags")]
-        public FCommandFlags Flags;
-
-        [NativeTypeName("__AnonymousRecord_Command_L271_C9")]
+        [NativeTypeName("__AnonymousRecord_Command_L517_C9")]
         public _Anonymous_e__Union Anonymous;
 
         [UnscopedRef]
-        public ref FCommandTransition Transition
+        public ref FCommandType Type
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.Transition;
+                return ref Anonymous.Type;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandPresent Present
+        public ref FCommandLabel Label
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.Present;
+                return ref Anonymous.Label;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandClearColor ClearColor
+        public ref FCommandBeginScope BeginScope
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.ClearColor;
+                return ref Anonymous.BeginScope;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandClearDepthStencil ClearDepthStencil
+        public ref FCommandEndScope EndScope
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.ClearDepthStencil;
+                return ref Anonymous.EndScope;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandSetRenderTargets SetRenderTargets
+        public ref FCommandSetPipeline SetPipeline
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.SetRenderTargets;
+                return ref Anonymous.SetPipeline;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandSetViewportScissor SetViewportScissor
+        public ref FCommandSetBinding SetBinding
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.SetViewportScissor;
+                return ref Anonymous.SetBinding;
             }
         }
 
         [UnscopedRef]
-        public ref FCommandSetPipeline SetPipeline
+        public ref FCommandSetViewportScissor SetViewportScissor
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return ref Anonymous.SetPipeline;
+                return ref Anonymous.SetViewportScissor;
             }
         }
 
@@ -2522,16 +3769,6 @@ public ref FCommandDispatch Dispatch
             }
         }
 
-        [UnscopedRef]
-        public ref FCommandBufferCopy BufferCopy
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return ref Anonymous.BufferCopy;
-            }
-        }
-
         [UnscopedRef]
         public Span<byte> _pad
         {
@@ -2546,32 +3783,32 @@ public Span<byte> _pad
         public partial struct _Anonymous_e__Union
         {
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandTransition")]
-            public FCommandTransition Transition;
+            [NativeTypeName("Coplt::FCommandType")]
+            public FCommandType Type;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandPresent")]
-            public FCommandPresent Present;
+            [NativeTypeName("Coplt::FCommandLabel")]
+            public FCommandLabel Label;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandClearColor")]
-            public FCommandClearColor ClearColor;
+            [NativeTypeName("Coplt::FCommandBeginScope")]
+            public FCommandBeginScope BeginScope;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandClearDepthStencil")]
-            public FCommandClearDepthStencil ClearDepthStencil;
+            [NativeTypeName("Coplt::FCommandEndScope")]
+            public FCommandEndScope EndScope;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandSetRenderTargets")]
-            public FCommandSetRenderTargets SetRenderTargets;
+            [NativeTypeName("Coplt::FCommandSetPipeline")]
+            public FCommandSetPipeline SetPipeline;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandSetViewportScissor")]
-            public FCommandSetViewportScissor SetViewportScissor;
+            [NativeTypeName("Coplt::FCommandSetBinding")]
+            public FCommandSetBinding SetBinding;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandSetPipeline")]
-            public FCommandSetPipeline SetPipeline;
+            [NativeTypeName("Coplt::FCommandSetViewportScissor")]
+            public FCommandSetViewportScissor SetViewportScissor;
 
             [FieldOffset(0)]
             [NativeTypeName("Coplt::FCommandSetMeshBuffers")]
@@ -2586,14 +3823,138 @@ public partial struct _Anonymous_e__Union
             public FCommandDispatch Dispatch;
 
             [FieldOffset(0)]
-            [NativeTypeName("Coplt::FCommandBufferCopy")]
-            public FCommandBufferCopy BufferCopy;
+            [NativeTypeName("u8[32]")]
+            public __pad_e__FixedBuffer _pad;
+
+            [InlineArray(32)]
+            public partial struct __pad_e__FixedBuffer
+            {
+                public byte e0;
+            }
+        }
+    }
+
+    public partial struct FComputeCommandItem
+    {
+        [NativeTypeName("__AnonymousRecord_Command_L540_C9")]
+        public _Anonymous_e__Union Anonymous;
+
+        [UnscopedRef]
+        public ref FCommandType Type
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Type;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandLabel Label
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Label;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandBeginScope BeginScope
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.BeginScope;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandEndScope EndScope
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.EndScope;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandSetPipeline SetPipeline
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.SetPipeline;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandSetBinding SetBinding
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.SetBinding;
+            }
+        }
+
+        [UnscopedRef]
+        public ref FCommandDispatch Dispatch
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return ref Anonymous.Dispatch;
+            }
+        }
+
+        [UnscopedRef]
+        public Span<byte> _pad
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return Anonymous._pad;
+            }
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public partial struct _Anonymous_e__Union
+        {
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandType")]
+            public FCommandType Type;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandLabel")]
+            public FCommandLabel Label;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandBeginScope")]
+            public FCommandBeginScope BeginScope;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandEndScope")]
+            public FCommandEndScope EndScope;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandSetPipeline")]
+            public FCommandSetPipeline SetPipeline;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandSetBinding")]
+            public FCommandSetBinding SetBinding;
+
+            [FieldOffset(0)]
+            [NativeTypeName("Coplt::FCommandDispatch")]
+            public FCommandDispatch Dispatch;
 
             [FieldOffset(0)]
-            [NativeTypeName("u8[56]")]
+            [NativeTypeName("u8[32]")]
             public __pad_e__FixedBuffer _pad;
 
-            [InlineArray(56)]
+            [InlineArray(32)]
             public partial struct __pad_e__FixedBuffer
             {
                 public byte e0;
@@ -2677,8 +4038,8 @@ public enum FShaderLayoutFlags : byte
 
     public unsafe partial struct FShaderLayoutCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::u32")]
         public uint Count;
@@ -2690,10 +4051,16 @@ public unsafe partial struct FShaderLayoutCreateOptions
         public FShaderLayoutFlags Flags;
     }
 
+    public partial struct FGetEmptyShaderLayoutOptions
+    {
+        [NativeTypeName("Coplt::FShaderLayoutFlags")]
+        public FShaderLayoutFlags Flags;
+    }
+
     public unsafe partial struct FShaderInputLayoutCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FShaderInputLayoutElement *")]
         public FShaderInputLayoutElement* Element;
@@ -2704,8 +4071,8 @@ public unsafe partial struct FShaderInputLayoutCreateOptions
 
     public unsafe partial struct FMeshLayoutCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FMeshBufferDefine *")]
         public FMeshBufferDefine* Buffers;
@@ -2756,10 +4123,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FMeshLayout*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FMeshLayout*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FMeshLayout*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FMeshLayout*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2798,8 +4165,8 @@ public interface Interface : FGpuObject.Interface
 
     public unsafe partial struct FShaderPipelineCreateOptions
     {
-        [NativeTypeName("Coplt::Str8or16")]
-        public Str8or16 Name;
+        [NativeTypeName("Coplt::FStr8or16")]
+        public FStr8or16 Name;
 
         [NativeTypeName("Coplt::FShader *")]
         public FShader* Shader;
@@ -2841,10 +4208,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShaderPipeline*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FShaderPipeline*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2917,10 +4284,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FComputeShaderPipeline*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FComputeShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FComputeShaderPipeline*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FComputeShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2997,10 +4364,10 @@ public nuint AddRef()
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [return: NativeTypeName("Coplt::FResult")]
-        public FResult SetName([NativeTypeName("const Str8or16 &")] Str8or16* name)
+        public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
         {
             FResult result;
-            return *((delegate* unmanaged[Thiscall]<FGraphicsShaderPipeline*, FResult*, Str8or16*, FResult*>)(lpVtbl[4]))((FGraphicsShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
+            return *((delegate* unmanaged[Thiscall]<FGraphicsShaderPipeline*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FGraphicsShaderPipeline*)Unsafe.AsPointer(ref this), &result, name);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -3410,20 +4777,32 @@ public static partial class Native
 
         public static readonly Guid IID_FInstance = new Guid(0xCC2894BA, 0x57C7, 0x474A, 0xB7, 0x77, 0x1A, 0x3E, 0x3A, 0x7C, 0x92, 0x2C);
 
+        public static readonly Guid IID_FGpuAdapter = new Guid(0xB3BBBED6, 0xE997, 0x4BD5, 0xBE, 0x53, 0x0A, 0xAC, 0x0C, 0xA8, 0x11, 0x4D);
+
         public static readonly Guid IID_FGpuDevice = new Guid(0x557F032D, 0xED50, 0x403A, 0xAD, 0xC5, 0x21, 0x4F, 0xDD, 0xBE, 0x6C, 0x6B);
 
         public static readonly Guid IID_FShaderModule = new Guid(0x5C0E1FDB, 0x2ACD, 0x4FCE, 0xB9, 0x85, 0x09, 0xE1, 0x2A, 0x7A, 0x1A, 0xAD);
 
         public static readonly Guid IID_FShader = new Guid(0xDE1352D5, 0x023D, 0x42B0, 0xBE, 0xAC, 0x12, 0x2B, 0x3B, 0x29, 0x6C, 0x9C);
 
+        public static readonly Guid IID_FShaderBinding = new Guid(0xA3CA644A, 0x0E02, 0x4D25, 0x9A, 0x18, 0x88, 0x35, 0xD6, 0x66, 0x00, 0xF7);
+
         public static readonly Guid IID_FFrameContext = new Guid(0x3A22DE68, 0x8377, 0x4E57, 0xA1, 0x67, 0x3E, 0xFD, 0xB9, 0x7C, 0x10, 0x2A);
 
         public static readonly Guid IID_FGpuQueue = new Guid(0x95E60E28, 0xE387, 0x4055, 0x9B, 0x33, 0x2D, 0x23, 0xAF, 0x90, 0x1F, 0x8A);
 
+        public static readonly Guid IID_FGpuExecutor = new Guid(0xEDAB0989, 0xE0C2, 0x4B1E, 0x82, 0x6F, 0xC7, 0x33, 0x80, 0x08, 0x8F, 0xC6);
+
+        public static readonly Guid IID_FGpuView = new Guid(0xB3AEB8A5, 0x1FA6, 0x4866, 0x97, 0xEF, 0x1A, 0x5F, 0xA4, 0x01, 0xE1, 0x8F);
+
         public static readonly Guid IID_FGpuResource = new Guid(0xF99DCEEC, 0x2F0C, 0x4A28, 0xB6, 0x66, 0xBE, 0xB7, 0xC3, 0x52, 0x19, 0xD6);
 
+        public static readonly Guid IID_FGpuTransientView = new Guid(0xF7DFC622, 0x972B, 0x49B2, 0x89, 0x99, 0x8F, 0xB1, 0x29, 0xC6, 0x1A, 0xC6);
+
         public static readonly Guid IID_FGpuBuffer = new Guid(0x283740E3, 0xFE96, 0x41D0, 0x83, 0x0A, 0x0A, 0x4C, 0x6A, 0x72, 0x53, 0x36);
 
+        public static readonly Guid IID_FGpuUploadBuffer = new Guid(0x3E85392D, 0x8FD3, 0x49EB, 0x98, 0x72, 0xCF, 0x7A, 0x0D, 0x7C, 0x8E, 0x4C);
+
         public static readonly Guid IID_FGpuImage = new Guid(0x667EFA36, 0x21C7, 0x4561, 0xAB, 0xAD, 0x85, 0x78, 0x0F, 0xA4, 0x92, 0x9E);
 
         public static readonly Guid IID_FGpuOutput = new Guid(0xF1C59CB4, 0x7EE6, 0x4EE2, 0x80, 0xF4, 0x07, 0xCC, 0x56, 0x89, 0x20, 0xD2);
diff --git a/Coplt.Graphics.Core/Native/ResState.cs b/Coplt.Graphics.Core/Native/ResState.cs
new file mode 100644
index 0000000..7e934d5
--- /dev/null
+++ b/Coplt.Graphics.Core/Native/ResState.cs
@@ -0,0 +1,126 @@
+using Coplt.Graphics.Core;
+using Coplt.Graphics.Native;
+
+namespace Coplt.Graphics.Native
+{
+    public partial struct FResState
+    {
+        /// <summary>
+        /// 判断状态是否兼容
+        /// </summary>
+        public readonly bool IsCompatible(in FResState other, bool legacy, /* 顺序 */ bool b2a, out bool same)
+        {
+            if (legacy)
+            {
+                same = Legacy == other.Legacy;
+                return Legacy.FromFFI().IsCompatible(other.Legacy.FromFFI());
+            }
+            if (Layout != other.Layout || CrossQueue != other.CrossQueue) goto no;
+            if (Access != other.Access)
+            {
+                same = false;
+                var sna = (Access.FromFFI() & ResAccess.NoAccess) != 0;
+                var ona = (other.Access.FromFFI() & ResAccess.NoAccess) != 0;
+                if (sna && ona) return true;
+                if (sna || ona)
+                {
+                    if (b2a)
+                    {
+                        if (sna && !ona) return true;
+                        else if (!sna && ona) return false;
+                    }
+                    else
+                    {
+                        if (!sna && ona) return true;
+                        else if (sna && !ona) return false;
+                    }
+                }
+                if (!Access.FromFFI().IsReadOnly() || !other.Access.FromFFI().IsReadOnly()) goto no;
+            }
+            else
+            {
+                same = Stages == other.Stages;
+            }
+            return true;
+        no:
+            same = false;
+            return false;
+        }
+
+        /// <summary>
+        /// 在兼容的时候合并，不兼容的话是未定义行为
+        /// </summary>
+        public readonly FResState Merge(in FResState other, bool legacy, /* 顺序 */ bool b2a)
+        {
+            if (legacy)
+            {
+                return new()
+                {
+                    Layout = Layout,
+                    Access = Access,
+                    Stages = Stages,
+                    // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                    Legacy = Legacy | other.Legacy,
+                    CrossQueue = CrossQueue,
+                };
+            }
+            var sna = (Access.FromFFI() & ResAccess.NoAccess) != 0;
+            var ona = (other.Access.FromFFI() & ResAccess.NoAccess) != 0;
+            if (b2a)
+            {
+                if (sna)
+                    return new()
+                    {
+                        Layout = Layout,
+                        // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                        Access = other.Access,
+                        // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                        Stages = Stages | other.Stages,
+                        Legacy = Legacy,
+                        CrossQueue = CrossQueue,
+                    };
+            }
+            else
+            {
+                if (ona)
+                    return new()
+                    {
+                        Layout = Layout,
+                        // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                        Access = Access,
+                        // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                        Stages = Stages | other.Stages,
+                        Legacy = Legacy,
+                        CrossQueue = CrossQueue,
+                    };
+            }
+            return new()
+            {
+                Layout = Layout,
+                // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                Access = Access | other.Access,
+                // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
+                Stages = Stages | other.Stages,
+                Legacy = Legacy,
+                CrossQueue = CrossQueue,
+            };
+        }
+
+        public override string ToString() =>
+            $"{{ {nameof(Layout)} = {Layout}, {nameof(Access)} = {Access}, {nameof(Stages)} = {Stages}, {nameof(Legacy)} = {Legacy}, {nameof(CrossQueue)} = {CrossQueue} }}";
+    }
+}
+
+namespace Coplt.Graphics.Core
+{
+    public static partial class GraphicsExtensions
+    {
+        public static bool ContainsOnly(this ResAccess value, ResAccess other) => (value & ~other) == 0;
+        public static bool Contains(this ResAccess value, ResAccess other) => (value & other) != 0;
+        public static bool IsReadOnly(this ResAccess value) => value.ContainsOnly(
+            ResAccess.IndexBuffer | ResAccess.ConstantBuffer | ResAccess.VertexBuffer | ResAccess.CopySrc |
+            ResAccess.ResolveSrc | ResAccess.DepthStencilRead | ResAccess.IndirectOrPredicationBuffer |
+            ResAccess.ShaderResource | ResAccess.ShadingRate
+        );
+    }
+}
diff --git a/Coplt.Graphics.Core/Native/Str8or16.cs b/Coplt.Graphics.Core/Native/Str8or16.cs
index 38472da..772c1e9 100644
--- a/Coplt.Graphics.Core/Native/Str8or16.cs
+++ b/Coplt.Graphics.Core/Native/Str8or16.cs
@@ -1,11 +1,49 @@
-namespace Coplt.Graphics.Native;
+using System.Text;
 
-public unsafe partial struct Str8or16
+namespace Coplt.Graphics.Native;
+
+public unsafe partial struct FStr8or16
 {
-    public Str8or16(string? name, ReadOnlySpan<byte> name8, char* p_name, byte* p_name8)
+    public FStr8or16(byte* p_name8, int size)
     {
-        str8 = name != null ? null : name8.Length > 0 ? p_name8 : null;
+        type = FStrType.Str8;
+        str8 = p_name8;
+        len = size;
+    }
+
+    public FStr8or16(char* p_name, int size)
+    {
+        type = FStrType.Str16;
         str16 = p_name;
-        len = name?.Length ?? name8.Length;
+        len = size;
+    }
+
+    public FStr8or16(string? name, ReadOnlySpan<byte> name8, char* p_name, byte* p_name8)
+    {
+        type = name == null && name8.Length > 0 ? FStrType.Str8 : FStrType.Str16;
+        switch (type)
+        {
+        case FStrType.Str16:
+            str16 = p_name;
+            len = name?.Length ?? 0;
+            break;
+        case FStrType.Str8:
+            str8 = p_name8;
+            len = name8.Length;
+            break;
+        default:
+            throw new ArgumentOutOfRangeException();
+        }
+    }
+
+    public override string ToString()
+    {
+        if (len == 0) return "";
+        return type switch
+        {
+            FStrType.Str16 => new ReadOnlySpan<char>(str16, len).ToString(),
+            FStrType.Str8  => Encoding.UTF8.GetString(new ReadOnlySpan<byte>(str8, len)),
+            _              => ""
+        };
     }
 }
diff --git a/Coplt.Graphics.Core/Utils/Utils.cs b/Coplt.Graphics.Core/Utils/Utils.cs
index 053e56a..36524f9 100644
--- a/Coplt.Graphics.Core/Utils/Utils.cs
+++ b/Coplt.Graphics.Core/Utils/Utils.cs
@@ -55,4 +55,11 @@ private struct AlignOfHelper<T> where T : unmanaged
     public static int AlignOf<T>() where T : unmanaged => sizeof(AlignOfHelper<T>) - sizeof(T);
 
     #endregion
+
+    #region List Span
+
+    internal static Span<T> AsSpan<T>(this List<T> self) => CollectionsMarshal.AsSpan(self);
+    internal static ref T At<T>(this List<T> self, int index) => ref CollectionsMarshal.AsSpan(self)[index];
+
+    #endregion
 }
diff --git a/Coplt.Graphics.Native.D3d12/Coplt.Graphics.Native.D3d12.csproj b/Coplt.Graphics.Native.D3d12.Win64/Coplt.Graphics.Native.D3d12.Win64.csproj
similarity index 82%
rename from Coplt.Graphics.Native.D3d12/Coplt.Graphics.Native.D3d12.csproj
rename to Coplt.Graphics.Native.D3d12.Win64/Coplt.Graphics.Native.D3d12.Win64.csproj
index 9b37802..51cbc91 100644
--- a/Coplt.Graphics.Native.D3d12/Coplt.Graphics.Native.D3d12.csproj
+++ b/Coplt.Graphics.Native.D3d12.Win64/Coplt.Graphics.Native.D3d12.Win64.csproj
@@ -8,11 +8,10 @@
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <IncludeBuildOutput>false</IncludeBuildOutput>
         <NoWarn>NU5128</NoWarn>
-        <AssemblyName>_d3d12_native_stub_</AssemblyName>
     </PropertyGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\Coplt.Graphics.Core\Coplt.Graphics.Core.csproj" />
+        <ProjectReference Include="..\Coplt.Graphics.Core\Coplt.Graphics.Core.csproj"/>
     </ItemGroup>
 
     <Target Name="NativeBuildDebug" BeforeTargets="Build" Condition="'$(Configuration)' == 'Debug'" Outputs="../build/debug/bin/**/*">
@@ -32,5 +31,12 @@
         </ItemGroup>
         <Copy SourceFiles="@(NativeOutputs)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" UseHardlinksIfPossible="true"/>
     </Target>
+    
+    <ItemGroup>
+        <None Include="../Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll" Visible="false">
+            <Pack>true</Pack>
+            <PackagePath>runtimes\win-x64\native\</PackagePath>
+        </None>
+    </ItemGroup>
 
 </Project>
diff --git a/Coplt.Graphics.Native/Api/CMakeLists.txt b/Coplt.Graphics.Native/Api/CMakeLists.txt
index e0b15b2..05e894f 100644
--- a/Coplt.Graphics.Native/Api/CMakeLists.txt
+++ b/Coplt.Graphics.Native/Api/CMakeLists.txt
@@ -43,6 +43,11 @@ add_library(${target_name} STATIC
     FFI/Blob.h
     Src/Blob.cc
     FFI/Context.h
+    FFI/Binding.h
+    FFI/Executor.h
+    FFI/Features.h
+    FFI/Adapter.h
+    Include/ChunkedVector.h
 )
 set_target_properties(${target_name} PROPERTIES LINKER_LANGUAGE CXX)
 add_library(Coplt::Graphics::Api ALIAS ${target_name})
@@ -53,4 +58,5 @@ target_link_libraries(${target_name}
     glm::glm
     mimalloc-static
     fmt::fmt
+    concurrentqueue
 )
diff --git a/Coplt.Graphics.Native/Api/FFI/Adapter.h b/Coplt.Graphics.Native/Api/FFI/Adapter.h
new file mode 100644
index 0000000..85aab46
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/FFI/Adapter.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Object.h"
+#include "Result.h"
+#include "Features.h"
+#include "Device.h"
+
+namespace Coplt
+{
+
+    COPLT_INTERFACE_DEFINE(FGpuAdapter, "b3bbbed6-e997-4bd5-be53-0aac0ca8114d", FUnknown)
+    {
+        FStr8or16 m_name{};
+        FStr8or16 m_driver{};
+        FStr8or16 m_driver_info{};
+        u32 m_vendor_id{};
+        u32 m_device_id{};
+        FD3dFeatureLevel m_d3d_feature_level{};
+        FVulkanVersion m_vulkan_version{};
+        FDeviceType m_device_type{};
+        FBackend m_backend{};
+        FDeviceFeatures m_features{};
+
+        virtual b8 IsSupport(const FDeviceRequires& Requires) noexcept = 0;
+
+        virtual FResult CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept = 0;
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/FFI/Binding.h b/Coplt.Graphics.Native/Api/FFI/Binding.h
new file mode 100644
index 0000000..d14b574
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/FFI/Binding.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "GpuObject.h"
+#include "Layout.h"
+#include "Resource.h"
+
+namespace Coplt
+{
+    struct FShaderBindingCreateOptions
+    {
+        FStr8or16 Name{};
+        FShaderLayout* Layout{};
+    };
+
+    struct FShaderBindingBatchSet
+    {
+        FView View{};
+        u32 Index{};
+    };
+
+    COPLT_INTERFACE_DEFINE(FShaderBinding, "a3ca644a-0e02-4d25-9a18-8835d66600f7", FGpuObject)
+    {
+        virtual FView* GetViews(u32* out_size) noexcept = 0;
+
+        virtual FResult Set(u32 count, const FShaderBindingBatchSet* bindings) noexcept = 0;
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/FFI/Command.h b/Coplt.Graphics.Native/Api/FFI/Command.h
index 21b83e6..854fd50 100644
--- a/Coplt.Graphics.Native/Api/FFI/Command.h
+++ b/Coplt.Graphics.Native/Api/FFI/Command.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Binding.h"
 #include "Blob.h"
 #include "Output.h"
 #include "Pipeline.h"
@@ -10,27 +11,41 @@ namespace Coplt
     enum class FCommandType : u32
     {
         None,
-        // 手动资源过渡
-        Transition,
+
+        Label,
+        BeginScope,
+        EndScope,
+
         // 仅内部使用
         Present,
+
+        // 手动屏障
+        Barrier,
+
         ClearColor,
         ClearDepthStencil,
-        SetRenderTargets,
-        SetViewportScissor,
+
+        Bind,
+
+        BufferCopy,
+
+        Render,
+        Compute,
+
+        // Render / Compute
         SetPipeline,
+        SetBinding,
+
+        // Render
+        SetViewportScissor,
         SetMeshBuffers,
         Draw,
+
+        // Render / Compute
         Dispatch,
-        BufferCopy,
     };
 
-    enum class FCommandFlags : u32
-    {
-        None = 0,
-        // 不要自动计算资源过渡
-        DontTransition = 1 << 0,
-    };
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
 
     enum class FResourceRefType : u8
     {
@@ -44,15 +59,14 @@ namespace Coplt
     {
         union
         {
-            FGpuOutput* Output;
+            FGpuOutput* Output{};
             FGpuBuffer* Buffer;
             // todo other
         };
 
-        FResourceState CurrentState{};
         FResourceRefType Type{};
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         FUnknown* GetObjectPtr() const
         {
             switch (Type)
@@ -66,7 +80,7 @@ namespace Coplt
             }
             return nullptr;
         }
-#endif
+        #endif
     };
 
     struct FResourceRef
@@ -74,22 +88,95 @@ namespace Coplt
         // u32::max 表示 empty
         u32 ResourceIndex{};
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         FResourceMeta& Get(const FCommandSubmit& submit) const;
 
         bool IsEmpty() const
         {
-            return ResourceIndex == COPLT_U32_MAX;
+            return ResourceIndex == 0;
         }
-#endif
+        #endif
+    };
+
+    struct FSubResourceRange
+    {
+        u32 IndexOrFirstMipLevel{};
+        u32 NumMipLevels{};
+        u32 FirstArraySlice{};
+        u32 NumArraySlices{};
+        u32 FirstPlane{};
+        u32 NumPlanes{};
+    };
+
+    COPLT_ENUM_FLAGS(FImageBarrierFlags, u32)
+    {
+        None,
+        Discard = 1 << 0,
+        CrossQueue = 1 << 1,
+    };
+
+    struct FImageBarrier
+    {
+        FLegacyState LegacyBefore{};
+        FLegacyState LegacyAfter{};
+        FResAccess AccessBefore{};
+        FResAccess AccessAfter{};
+        FShaderStageFlags StagesBefore{};
+        FShaderStageFlags StagesAfter{};
+        FResLayout LayoutBefore{};
+        FResLayout LayoutAfter{};
+        FResourceRef Image{};
+        FSubResourceRange SubResourceRange{};
+        FImageBarrierFlags Flags{};
+    };
+
+    struct FBufferBarrier
+    {
+        FLegacyState LegacyBefore{};
+        FLegacyState LegacyAfter{};
+        FResAccess AccessBefore{};
+        FResAccess AccessAfter{};
+        FShaderStageFlags StagesBefore{};
+        FShaderStageFlags StagesAfter{};
+        FResourceRef Buffer{};
+        u64 Offset{};
+        u64 Size{};
+    };
+
+    struct FGlobalBarrier
+    {
+        FResAccess AccessBefore{};
+        FResAccess AccessAfter{};
+        FShaderStageFlags StagesBefore{};
+        FShaderStageFlags StagesAfter{};
+    };
+
+    enum class FBarrierType : u8
+    {
+        None,
+        Global,
+        Buffer,
+        Image,
+    };
+
+    struct FBarrier
+    {
+        FBarrierType Type{};
+
+        union
+        {
+            FGlobalBarrier Global;
+            FBufferBarrier Buffer;
+            FImageBarrier Image;
+        };
     };
 
     struct FRect
     {
-        u32 left;
-        u32 top;
-        u32 right;
-        u32 bottom;
+        u32 Left;
+        u32 Top;
+        u32 Right;
+        u32 Bottom;
     };
 
     struct FViewport
@@ -102,79 +189,102 @@ namespace Coplt
         f32 MaxDepth;
     };
 
-    struct FCommandTransition
+    COPLT_ENUM_FLAGS(FDepthStencilClearFlags, u8)
     {
-        FResourceRef Resource{};
-        FResourceState SrcState{};
-        FResourceState DstState{};
+        None = 0,
+        Depth = 1,
+        Stencil = 2,
     };
 
-    struct FCommandPresent
+    struct FBindItem
     {
-        FResourceRef Image{};
+        FCommandType Type{};
+        FView View{};
+        u32 Index{};
     };
 
-    struct FCommandClearColor
+    struct FUploadLoc
     {
-        // 有多少个 Rect
-        u32 RectCount{};
-        // Payload 内的索引
-        u32 RectIndex{};
-        FResourceRef Image{};
-        f32 Color[4]{};
+        u32 Index{};
     };
 
-    COPLT_ENUM_FLAGS(FDepthStencilClearFlags, u8)
+    union FBufferRef
     {
-        None = 0,
-        Depth = 1,
-        Stencil = 2,
+        FResourceRef Buffer;
+        FUploadLoc Upload;
     };
 
-    struct FCommandClearDepthStencil
+    enum class FBufferRefType : u8
     {
-        // 有多少个 Rect
-        u32 RectCount{};
-        // Payload 内的索引
-        u32 RectIndex{};
-        FResourceRef Image{};
-        f32 Depth{};
-        u8 Stencil{};
-        FDepthStencilClearFlags Clear{};
+        // GpuBuffer 对象资源引用
+        Buffer = 0,
+        // 当前帧上下文中第几个上传缓冲区
+        Upload,
     };
 
-    struct FCommandSetRenderTargets
+    struct FBufferCopyRange
     {
-        // 可选
-        FResourceRef Dsv{};
-        u32 NumRtv{};
-        FResourceRef Rtv[8]{};
+        // Size 为 u64::max 时复制整个
+        u64 Size{};
+        u64 DstOffset{};
+        u64 SrcOffset{};
+    };
 
-        // 有多少个 Viewport
-        u32 ViewportCount{};
-        // Payload 内的索引
-        u32 ViewportIndex{};
-        // 有多少个 Rect
-        u32 ScissorRectCount{};
-        // Payload 内的索引
-        u32 ScissorRectIndex{};
+    enum class FResolveMode : u8
+    {
+        Decompress,
+        Min,
+        Max,
+        Average,
     };
 
-    struct FCommandSetViewportScissor
+    struct FResolveInfo
     {
-        // 有多少个 Viewport
-        u32 ViewportCount{};
-        // Payload 内的索引
-        u32 ViewportIndex{};
-        // 有多少个 Rect
-        u32 ScissorRectCount{};
-        // Payload 内的索引
-        u32 ScissorRectIndex{};
+        FResourceRef Src{};
+        FResourceRef Dst{};
+        FGraphicsFormat Format{};
+        FResolveMode Mode{};
     };
 
-    struct FCommandSetPipeline
+    enum class FLoadOp : u8
+    {
+        Load,
+        Clear,
+        Discard,
+        NoAccess,
+    };
+
+    enum class FStoreOp : u8
+    {
+        Store,
+        Discard,
+        Resolve,
+        NoAccess,
+    };
+
+    struct FRenderInfo
+    {
+        // 可选
+        FResourceRef Dsv{};
+        u32 NumRtv{};
+        FResourceRef Rtv[8]{};
+        // 类型为 FResolveInfo
+        u32 ResolveInfoIndex[8]{};
+        u32 DsvResolveInfoIndex{};
+        FGraphicsFormat RtvFormat[8]{};
+        FGraphicsFormat DsvFormat{};
+        f32 Color[4 * 8]{};
+        f32 Depth{};
+        u8 Stencil{};
+        FLoadOp DsvLoadOp[2]{};
+        FStoreOp DsvStoreOp[2]{};
+        FLoadOp RtvLoadOp[8]{};
+        FStoreOp RtvStoreOp[8]{};
+        b8 HasUavWrites{};
+    };
+
+    struct FComputeInfo
     {
-        FShaderPipeline* Pipeline{};
     };
 
     struct FBufferRange
@@ -189,123 +299,296 @@ namespace Coplt
         u32 Index{};
     };
 
-    struct FCommandSetMeshBuffers
+    struct FMeshBuffers
     {
         FMeshLayout* MeshLayout{};
-        FGraphicsFormat IndexFormat{};
         // 可选
         FBufferRange IndexBuffer{};
         // 0 .. 31
-        u32 VertexStartSlot{};
-        // 0 .. 31
         u32 VertexBufferCount{};
         // Payload 内的索引，类型为 FVertexBufferRange
         u32 VertexBuffersIndex{};
     };
 
-    struct FCommandDraw
-    {
-        // 可选
-        FShaderPipeline* Pipeline{};
-        u32 VertexOrIndexCount{};
-        u32 InstanceCount{};
-        u32 FirstVertexOrIndex{};
-        u32 FirstInstance{};
-        // 仅 Indexed 使用
-        u32 VertexOffset{};
-        b8 Indexed{};
-    };
-
     enum class FDispatchType : u8
     {
         Compute,
         Mesh,
     };
 
-    struct FCommandDispatch
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandBase
     {
-        // 可选
-        FShaderPipeline* Pipeline{};
-        u32 GroupCountX{};
-        u32 GroupCountY{};
-        u32 GroupCountZ{};
-        FDispatchType Type{};
+        FCommandType Type{};
     };
 
-    struct FUploadLoc
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandLabel : FCommandBase
     {
-        u32 Index{};
+        u32 StringIndex{};
+        u32 StringLength{};
+        FStrType StrType{};
+        u8 Color[3]{};
+        b8 HasColor{};
     };
 
-    union FBufferRef
+    struct FCommandBeginScope : FCommandBase
     {
-        FResourceRef Buffer;
-        FUploadLoc Upload;
+        u32 StringIndex{};
+        u32 StringLength{};
+        FStrType StrType{};
+        u8 Color[3]{};
+        b8 HasColor{};
     };
 
-    enum class FBufferRefType : u8
+    struct FCommandEndScope : FCommandBase
     {
-        // GpuBuffer 对象资源引用
-        Buffer = 0,
-        // 当前帧上下文中第几个上传缓冲区
-        Upload,
     };
 
-    struct FCommandBufferCopy
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandPresent : FCommandBase
     {
-        // Size 为 u64::max 时复制整个
-        u64 Size{};
-        u64 DstOffset{};
-        u64 SrcOffset{};
+        FResourceRef Image{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandBarrier : FCommandBase
+    {
+        // Payload 内的索引，类型为 FBarrier
+        u32 BarrierIndex{};
+        u32 BarrierCount{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandClearColor : FCommandBase
+    {
+        // 有多少个 Rect
+        u32 RectCount{};
+        // Payload 内的索引
+        u32 RectIndex{};
+        FResourceRef Image{};
+        f32 Color[4]{};
+    };
+
+    struct FCommandClearDepthStencil : FCommandBase
+    {
+        // 有多少个 Rect
+        u32 RectCount{};
+        // Payload 内的索引, 类型为 FRect
+        u32 RectIndex{};
+        FResourceRef Image{};
+        f32 Depth{};
+        u8 Stencil{};
+        FDepthStencilClearFlags Clear{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandBind : FCommandBase
+    {
+        // 有多少个绑定修改
+        u32 ItemCount{};
+        // Payload 内的索引, 类型为 FBindItem
+        u32 ItemsIndex{};
+        // 要修改的绑定集
+        FShaderBinding* Binding{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandBufferCopy : FCommandBase
+    {
+        // 类型为 FBufferCopyRange
+        u32 RangeIndex{};
         FBufferRef Dst{};
         FBufferRef Src{};
         FBufferRefType DstType{};
         FBufferRefType SrcType{};
     };
 
-    struct FCommandItem
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandRender : FCommandBase
     {
-        FCommandType Type{};
-        FCommandFlags Flags{};
+        // 类型为 FRenderInfo
+        u32 InfoIndex{};
+        u32 CommandStartIndex{};
+        u32 CommandCount{};
+    };
+
+    struct FCommandCompute : FCommandBase
+    {
+        // 类型为 FComputeInfo
+        u32 InfoIndex{};
+        u32 CommandStartIndex{};
+        u32 CommandCount{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandSetPipeline : FCommandBase
+    {
+        FShaderPipeline* Pipeline{};
+    };
+
+    struct FCommandSetBinding : FCommandBase
+    {
+        FShaderBinding* Binding{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    struct FCommandSetViewportScissor : FCommandBase
+    {
+        // 有多少个 Viewport
+        u32 ViewportCount{};
+        // Payload 内的索引
+        u32 ViewportIndex{};
+        // 有多少个 Rect
+        u32 ScissorRectCount{};
+        // Payload 内的索引, 类型为 FRect
+        u32 ScissorRectIndex{};
+    };
+
+    struct FCommandSetMeshBuffers : FCommandBase
+    {
+        FGraphicsFormat IndexFormat{};
+        // 0 .. 31
+        u32 VertexStartSlot{};
+        // 类型为 FMeshBuffers
+        u32 PayloadIndex{};
+    };
+
+    struct FCommandDraw : FCommandBase
+    {
+        u32 VertexOrIndexCount{};
+        u32 InstanceCount{};
+        u32 FirstVertexOrIndex{};
+        u32 FirstInstance{};
+        // 仅 Indexed 使用
+        u32 VertexOffset{};
+        b8 Indexed{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandDispatch : FCommandBase
+    {
+        u32 GroupCountX{};
+        u32 GroupCountY{};
+        u32 GroupCountZ{};
+        FDispatchType Type{};
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    struct FCommandItem
+    {
         union
         {
-            FCommandTransition Transition;
+            FCommandType Type{};
+
+            FCommandLabel Label;
+            FCommandBeginScope BeginScope;
+            FCommandEndScope EndScope;
+
             FCommandPresent Present;
+
+            FCommandBarrier Barrier;
+
             FCommandClearColor ClearColor;
             FCommandClearDepthStencil ClearDepthStencil;
-            FCommandSetRenderTargets SetRenderTargets;
-            FCommandSetViewportScissor SetViewportScissor;
+
+            FCommandBind Bind;
+
+            FCommandBufferCopy BufferCopy;
+
+            FCommandRender Render;
+            FCommandCompute Compute;
+
+            u8 _pad[32];
+        };
+    };
+
+    struct FRenderCommandItem
+    {
+        union
+        {
+            FCommandType Type{};
+
+            FCommandLabel Label;
+            FCommandBeginScope BeginScope;
+            FCommandEndScope EndScope;
+
             FCommandSetPipeline SetPipeline;
+            FCommandSetBinding SetBinding;
+
+            FCommandSetViewportScissor SetViewportScissor;
             FCommandSetMeshBuffers SetMeshBuffers;
             FCommandDraw Draw;
+
             FCommandDispatch Dispatch;
-            FCommandBufferCopy BufferCopy;
 
-            u8 _pad[56]{};
+            u8 _pad[32];
         };
     };
 
+    struct FComputeCommandItem
+    {
+        union
+        {
+            FCommandType Type{};
+
+            FCommandLabel Label;
+            FCommandBeginScope BeginScope;
+            FCommandEndScope EndScope;
+
+            FCommandSetPipeline SetPipeline;
+            FCommandSetBinding SetBinding;
+
+            FCommandDispatch Dispatch;
+
+            u8 _pad[32];
+        };
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
     struct FCommandSubmit
     {
-        // 有多少命令
-        u32 CommandCount{};
-        // 有多少资源
-        u32 ResourceCount{};
-        // 需要保证对象指针生命周期 >= FCommandSubmit 的生命周期，提交操作可能会修改此内存，提交后内存将无效
         FCommandItem* Commands{};
-        // 需要保证对象指针生命周期 >= FCommandSubmit 的生命周期，提交操作可能会修改此内存，提交后内存将无效
+        FRenderCommandItem* RenderCommands{};
+        FComputeCommandItem* ComputeCommands{};
         FResourceMeta* Resources{};
-        // 需要保证对象指针生命周期 >= FCommandSubmit 的生命周期，提交操作可能会修改此内存，提交后内存将无效
-        u8* Payload{};
+        FRenderInfo* RenderInfos{};
+        FComputeInfo* ComputeInfos{};
+        FResolveInfo* ResolveInfos{};
+        FRect* Rects{};
+        FViewport* Viewports{};
+        FMeshBuffers* MeshBuffers{};
+        FVertexBufferRange* VertexBufferRanges{};
+        FBufferCopyRange* BufferCopyRanges{};
+        FBindItem* BindItems{};
+        FBarrier* Barriers{};
+        Char8* Str8{};
+        Char16* Str16{};
+        u32 CommandCount{};
+        u32 ResourceCount{};
     };
 
-#ifdef FFI_SRC
+    ////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    #ifdef FFI_SRC
 
     inline FResourceMeta& FResourceRef::Get(const FCommandSubmit& submit) const
     {
-        return submit.Resources[ResourceIndex];
+        return submit.Resources[ResourceIndex - 1];
     }
 
-#endif
+    #endif
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Common.h b/Coplt.Graphics.Native/Api/FFI/Common.h
index 65c2d60..370da4c 100644
--- a/Coplt.Graphics.Native/Api/FFI/Common.h
+++ b/Coplt.Graphics.Native/Api/FFI/Common.h
@@ -66,47 +66,55 @@
 
 #ifdef FFI_SRC
 #define COPLT_ENUM_FLAGS(Name, Type) enum class Name : Type;\
-inline bool operator==(const Name a, const Type b)\
+inline constexpr bool operator==(const Name a, const Type b)\
 {\
     return static_cast<Type>(a) == b;\
 }\
-inline bool operator!=(const Name a, const Type b)\
+inline constexpr bool operator!=(const Name a, const Type b)\
 {\
     return static_cast<Type>(a) != b;\
 }\
-inline Name operator~(const Name value)\
+inline constexpr bool operator&&(const Name a, const Name b)\
+{\
+return (a != 0) && (b != 0);\
+}\
+inline constexpr bool operator||(const Name a, const Name b)\
+{\
+return (a != 0) || (b != 0);\
+}\
+inline constexpr Name operator~(const Name value)\
 {\
     return static_cast<Name>(~static_cast<Type>(value));\
 }\
-inline Name operator&(const Name a, const Name b)\
+inline constexpr Name operator&(const Name a, const Name b)\
 {\
     return static_cast<Name>(static_cast<Type>(a) & static_cast<Type>(b));\
 }\
-inline Name operator|(const Name a, const Name b)\
+inline constexpr Name operator|(const Name a, const Name b)\
 {\
     return static_cast<Name>(static_cast<Type>(a) | static_cast<Type>(b));\
 }\
-inline Name operator^(const Name a, const Name b)\
+inline constexpr Name operator^(const Name a, const Name b)\
 {\
     return static_cast<Name>(static_cast<Type>(a) ^ static_cast<Type>(b));\
 }\
-inline Name operator&=(Name& a, const Name b)\
+inline constexpr Name operator&=(Name& a, const Name b)\
 {\
     return a = a & b;\
 }\
-inline Name operator|=(Name& a, const Name b)\
+inline constexpr Name operator|=(Name& a, const Name b)\
 {\
     return a = a | b;\
 }\
-inline Name operator^=(Name& a, const Name b)\
+inline constexpr Name operator^=(Name& a, const Name b)\
 {\
     return a = a ^ b;\
 }\
-inline bool HasFlags(Name a, Name b)\
+inline constexpr bool HasFlags(Name a, Name b)\
 {\
     return (a & b) == b;\
 }\
-inline bool HasAnyFlags(Name a, Name b)\
+inline constexpr bool HasAnyFlags(Name a, Name b)\
 {\
     return (a & b) != 0;\
 }\
diff --git a/Coplt.Graphics.Native/Api/FFI/Device.h b/Coplt.Graphics.Native/Api/FFI/Device.h
index db253bc..7cc3655 100644
--- a/Coplt.Graphics.Native/Api/FFI/Device.h
+++ b/Coplt.Graphics.Native/Api/FFI/Device.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Binding.h"
+#include "Features.h"
 #include "GpuObject.h"
 #include "Layout.h"
 #include "Queue.h"
@@ -24,28 +26,52 @@ namespace Coplt
         _12_2 = 0xc200,
     };
 
-    enum class FGpuPreference : u8
+    enum class FDeviceTypeRequire : u8
     {
-        HighPerformance = 0,
-        MinimumPower = 1,
-        Any = 255,
+        Any,
+        Gpu,
+        IntegratedGpu,
+        DiscreteGpu,
+        VirtualGpu,
+        Cpu,
     };
 
-    struct FGpuDeviceCreateOptions
+    enum class FDeviceType : u8
+    {
+        Other,
+        IntegratedGpu,
+        DiscreteGpu,
+        VirtualGpu,
+        Cpu,
+    };
+
+    struct FDeviceRequires
     {
-        // 可选
-        Str8or16 Name{};
         // 仅 dx 后端时可用
         FD3dFeatureLevel D3dFeatureLevel{};
         // 仅 vk 后端时可用
         FVulkanVersion VulkanVersion{};
-        FGpuPreference Preference{};
-        b8 Debug{};
-        b8 GpuBasedValidation{};
+        FDeviceTypeRequire DeviceType{};
+        FDeviceFeatureRequires FeatureRequires{};
     };
 
+    struct FGpuDeviceCreateOptions
+    {
+        // 可选
+        FStr8or16 Name{};
+    };
+
+    struct FGpuAutoSelectDeviceCreateOptions : FGpuDeviceCreateOptions
+    {
+        FDeviceRequires Requires{};
+    };
+
+    struct FGpuAdapter;
+
     COPLT_INTERFACE_DEFINE(FGpuDevice, "557f032d-ed50-403a-adc5-214fddbe6c6b", FGpuObject)
     {
+        virtual FGpuAdapter* GetAdapter() noexcept = 0;
+
         // d3d12 返回 ID3D12Device*
         virtual void* GetRawDevice() noexcept = 0;
 
@@ -53,16 +79,14 @@ namespace Coplt
 
         virtual FResult CreateShaderModule(const FShaderModuleCreateOptions& options, FShaderModule** out) noexcept = 0;
         virtual FResult CreateShaderLayout(const FShaderLayoutCreateOptions& options, FShaderLayout** out) noexcept = 0;
-        virtual FResult CreateShaderInputLayout(
-            const FShaderInputLayoutCreateOptions& options, FShaderInputLayout** out
-        ) noexcept = 0;
+        virtual FResult GetEmptyShaderLayout(const FGetEmptyShaderLayoutOptions& options, FShaderLayout** out) noexcept = 0;
+        virtual FResult CreateShaderInputLayout(const FShaderInputLayoutCreateOptions& options, FShaderInputLayout** out) noexcept = 0;
         virtual FResult CreateShader(const FShaderCreateOptions& options, FShader** out) noexcept = 0;
+        virtual FResult CreateShaderBinding(const FShaderBindingCreateOptions& options, FShaderBinding** out) noexcept = 0;
 
         virtual FResult CreateMeshLayout(const FMeshLayoutCreateOptions& options, FMeshLayout** out) noexcept = 0;
 
-        virtual FResult CreateGraphicsPipeline(
-            const FGraphicsShaderPipelineCreateOptions& options, FGraphicsShaderPipeline** out
-        ) noexcept = 0;
+        virtual FResult CreateGraphicsPipeline(const FGraphicsShaderPipelineCreateOptions& options, FGraphicsShaderPipeline** out) noexcept = 0;
 
         virtual FResult CreateBuffer(const FGpuBufferCreateOptions& options, FGpuBuffer** out) noexcept = 0;
     };
diff --git a/Coplt.Graphics.Native/Api/FFI/Executor.h b/Coplt.Graphics.Native/Api/FFI/Executor.h
new file mode 100644
index 0000000..e697f5d
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/FFI/Executor.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "GpuObject.h"
+
+namespace Coplt
+{
+    COPLT_INTERFACE_DEFINE(FGpuExecutor, "edab0989-e0c2-4b1e-826f-c73380088fc6", FGpuObject)
+    {
+        // 等待可重用，在提交后必须先等待才能再次提交
+        virtual FResult Wait() noexcept = 0;
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/FFI/Features.h b/Coplt.Graphics.Native/Api/FFI/Features.h
new file mode 100644
index 0000000..d0f3d54
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/FFI/Features.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Common.h"
+
+namespace Coplt
+{
+    enum class FShaderModelLevel : u32
+    {
+        Any = 0,
+        SM_5_1 = 0x51,
+        SM_6_0 = 0x60,
+        SM_6_1 = 0x61,
+        SM_6_2 = 0x62,
+        SM_6_3 = 0x63,
+        SM_6_4 = 0x64,
+        SM_6_5 = 0x65,
+        SM_6_6 = 0x66,
+        SM_6_7 = 0x67,
+        SM_6_8 = 0x68,
+        SM_6_9 = 0x69,
+    };
+
+    struct FDeviceFeatureRequires
+    {
+        // 兼容的 hlsl 着色器模型级别
+        FShaderModelLevel ShaderModelLevel{};
+        // 光追
+        b8 RayTracing{};
+        // 网格着色器
+        b8 MeshShader{};
+        // 描述符堆，dx 后端忽略，vk 使用 VK_EXT_descriptor_buffer
+        b8 DescriptorHeap{};
+        // 增强屏障，vk 后端忽略
+        b8 EnhancedBarriers{};
+        // 假 · 无绑定, dx 后端后端忽略
+        b8 ArrBindless{};
+        // 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
+        b8 DynBindless{};
+    };
+
+    struct FDeviceFeatures
+    {
+        // 兼容的 hlsl 着色器模型级别
+        FShaderModelLevel ShaderModelLevel{};
+        // 光追
+        b8 RayTracing{};
+        // 网格着色器
+        b8 MeshShader{};
+        // 描述符堆，dx 后端永远为 true，vk 使用 VK_EXT_descriptor_buffer
+        b8 DescriptorHeap{};
+        // 增强屏障，vk 后端永远为 true
+        b8 EnhancedBarriers{};
+        // 假 · 无绑定, dx 后端永远为 true
+        b8 ArrBindless{};
+        // 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
+        b8 DynBindless{};
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/FFI/GpuObject.h b/Coplt.Graphics.Native/Api/FFI/GpuObject.h
index d8c3f2b..bb365e2 100644
--- a/Coplt.Graphics.Native/Api/FFI/GpuObject.h
+++ b/Coplt.Graphics.Native/Api/FFI/GpuObject.h
@@ -8,6 +8,6 @@ namespace Coplt
 {
     COPLT_INTERFACE_DEFINE(FGpuObject, "9fc6890b-e9a2-4f4a-9217-a14a4223a715", FUnknown)
     {
-        virtual FResult SetName(const Str8or16& name) noexcept = 0;
+        virtual FResult SetName(const FStr8or16& name) noexcept = 0;
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Instance.h b/Coplt.Graphics.Native/Api/FFI/Instance.h
index 3708735..b3dac0b 100644
--- a/Coplt.Graphics.Native/Api/FFI/Instance.h
+++ b/Coplt.Graphics.Native/Api/FFI/Instance.h
@@ -6,6 +6,13 @@
 
 namespace Coplt
 {
+    enum class FBackend : u8
+    {
+        None,
+        Dx12,
+        Vulkan,
+    };
+
     COPLT_INTERFACE_DEFINE(FAllocator, "534b3c0c-098d-4157-8add-9b79eb5d690f", FUnknown)
     {
         virtual void* MemoryAlloc(size_t size) noexcept = 0;
@@ -16,13 +23,22 @@ namespace Coplt
         virtual void MemoryFree(void* p, size_t align) noexcept = 0;
     };
 
-    struct FGpuDeviceCreateOptions;
+    struct FGpuAdapter;
+    struct FGpuAutoSelectDeviceCreateOptions;
     struct FGpuDevice;
 
+    struct FInstanceCreateOptions
+    {
+        b8 Debug{};
+        b8 GpuBasedValidation{};
+    };
+
     COPLT_INTERFACE_DEFINE(FInstance, "cc2894ba-57c7-474a-b777-1a3e3a7c922c", FUnknown)
     {
         // 外部只能读取
         FAllocator* m_allocator{};
+        b8 m_debug_enabled{};
+        b8 m_gpu_based_validation_enabled{};
 
         virtual FResult SetLogger(const FLogger& logger) noexcept = 0;
 
@@ -31,6 +47,7 @@ namespace Coplt
 
         virtual FResult CreateBlob(usize size, FBlob** out) noexcept = 0;
 
-        virtual FResult CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept = 0;
+        virtual FGpuAdapter* const* GetAdapters(u32* out_count) noexcept = 0;
+        virtual FResult CreateDevice(const FGpuAutoSelectDeviceCreateOptions& options, FGpuDevice** out) noexcept = 0;
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Layout.h b/Coplt.Graphics.Native/Api/FFI/Layout.h
index cc407b6..d278ca8 100644
--- a/Coplt.Graphics.Native/Api/FFI/Layout.h
+++ b/Coplt.Graphics.Native/Api/FFI/Layout.h
@@ -61,6 +61,41 @@ namespace Coplt
         FShaderLayoutItemView View{};
         FShaderLayoutItemType Type{};
         FShaderLayoutItemUsage Usage{};
+
+#ifdef FFI_SRC
+        bool IsAllowBuffer() const
+        {
+            switch (Type)
+            {
+            case FShaderLayoutItemType::ConstantBuffer:
+            case FShaderLayoutItemType::RawBuffer:
+            case FShaderLayoutItemType::StructureBuffer:
+            case FShaderLayoutItemType::StructureBufferWithCounter:
+                return true;
+            default:
+                return false;
+            }
+        }
+
+        bool IsAllowTexture() const
+        {
+            switch (Type)
+            {
+            case FShaderLayoutItemType::Texture1D:
+            case FShaderLayoutItemType::Texture1DArray:
+            case FShaderLayoutItemType::Texture2D:
+            case FShaderLayoutItemType::Texture2DArray:
+            case FShaderLayoutItemType::Texture2DMultisample:
+            case FShaderLayoutItemType::Texture2DArrayMultisample:
+            case FShaderLayoutItemType::Texture3D:
+            case FShaderLayoutItemType::TextureCube:
+            case FShaderLayoutItemType::TextureCubeArray:
+                return true;
+            default:
+                return false;
+            }
+        }
+#endif
     };
 
     COPLT_ENUM_FLAGS(FShaderLayoutFlags, u8)
@@ -76,7 +111,7 @@ namespace Coplt
 
     struct FShaderLayoutCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         u32 Count{};
         FShaderLayoutItemDefine* Items{};
         // todo 静态采样器
@@ -84,6 +119,11 @@ namespace Coplt
         FShaderLayoutFlags Flags{};
     };
 
+    struct FGetEmptyShaderLayoutOptions
+    {
+        FShaderLayoutFlags Flags{};
+    };
+
     COPLT_INTERFACE_DEFINE(FShaderLayout, "552a498e-8f3a-47ff-a335-7af2de0901e8", FGpuObject)
     {
         FShaderLayoutFlags Flags{};
@@ -101,7 +141,7 @@ namespace Coplt
 
     struct FShaderInputLayoutCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         FShaderInputLayoutElement* Element{};
         u32 Count{};
     };
@@ -121,7 +161,7 @@ namespace Coplt
 
     struct FMeshLayoutCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         // Buffers 按顺序定义到 InputSlot，不允许随机隔空的 InputSlot
         FMeshBufferDefine* Buffers{};
         FMeshBufferElement* Elements{};
@@ -131,10 +171,10 @@ namespace Coplt
 
     COPLT_INTERFACE_DEFINE(FMeshLayout, "8fe5121f-c2ce-46f5-aa14-f28595f35361", FGpuObject)
     {
-        virtual const FMeshBufferDefine* GetBuffers(u32* out_count) const  noexcept = 0;
-        virtual const FMeshBufferElement* GetElements(u32* out_count) const  noexcept = 0;
+        virtual const FMeshBufferDefine* GetBuffers(u32* out_count) const noexcept = 0;
+        virtual const FMeshBufferElement* GetElements(u32* out_count) const noexcept = 0;
 
-        virtual const FMeshBufferElement* TryGetElement(u32 SlotId, u32 SlotIndex) const  noexcept = 0;
+        virtual const FMeshBufferElement* TryGetElement(u32 SlotId, u32 SlotIndex) const noexcept = 0;
 
 #if FFI_SRC
         std::span<const FMeshBufferDefine> GetBuffers() const noexcept
@@ -143,7 +183,7 @@ namespace Coplt
             return std::span{GetBuffers(&count), static_cast<usize>(count)};
         }
 
-        std::span<const FMeshBufferElement> GetElements() const  noexcept
+        std::span<const FMeshBufferElement> GetElements() const noexcept
         {
             u32 count{};
             return std::span{GetElements(&count), static_cast<usize>(count)};
diff --git a/Coplt.Graphics.Native/Api/FFI/Output.h b/Coplt.Graphics.Native/Api/FFI/Output.h
index 98fcde3..8f0cb88 100644
--- a/Coplt.Graphics.Native/Api/FFI/Output.h
+++ b/Coplt.Graphics.Native/Api/FFI/Output.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Executor.h"
 #include "GpuObject.h"
 #include "States.h"
 #include "GraphicsFormat.h"
@@ -46,7 +47,7 @@ namespace Coplt
 
     struct FGpuOutputCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         u32 Width{};
         u32 Height{};
         FGraphicsFormat Format{};
@@ -61,26 +62,19 @@ namespace Coplt
 
     struct FCommandSubmit;
 
-    COPLT_INTERFACE_DEFINE(FGpuOutput, "f1c59cb4-7ee6-4ee2-80f4-07cc568920d2", FGpuObject)
+    COPLT_INTERFACE_DEFINE(FGpuOutput, "f1c59cb4-7ee6-4ee2-80f4-07cc568920d2", FGpuExecutor)
     {
-        FResourceState m_state;
+        FResState m_state{};
         // 外部不允许修改
-        FGraphicsFormat m_format;
+        FGraphicsFormat m_format{};
         // 外部不允许修改
-        u32 m_width;
+        u32 m_width{};
         // 外部不允许修改
-        u32 m_height;
+        u32 m_height{};
 
         // 设置垂直同步，实现可以选择忽略
         virtual FResult SetVSync(b8 Enable) noexcept = 0;
 
         virtual FResult Resize(u32 Width, u32 Height) noexcept = 0;
-
-        // 提交命令并等待下帧可用
-        virtual FResult Present(/* 可选 */ const FCommandSubmit* submit) noexcept = 0;
-        // 提交命令
-        virtual FResult PresentNoWait(/* 可选 */ const FCommandSubmit* submit) noexcept = 0;
-        // 等待下帧可用
-        virtual FResult WaitNextFrame() noexcept = 0;
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Pipeline.h b/Coplt.Graphics.Native/Api/FFI/Pipeline.h
index c48594e..03dad7b 100644
--- a/Coplt.Graphics.Native/Api/FFI/Pipeline.h
+++ b/Coplt.Graphics.Native/Api/FFI/Pipeline.h
@@ -8,7 +8,7 @@ namespace Coplt
 {
     struct FShaderPipelineCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         FShader* Shader{};
     };
 
diff --git a/Coplt.Graphics.Native/Api/FFI/Queue.h b/Coplt.Graphics.Native/Api/FFI/Queue.h
index d3c845a..9c657c0 100644
--- a/Coplt.Graphics.Native/Api/FFI/Queue.h
+++ b/Coplt.Graphics.Native/Api/FFI/Queue.h
@@ -10,7 +10,7 @@ namespace Coplt
     struct FMainQueueCreateOptions
     {
         // 可选
-        Str8or16 Name{};
+        FStr8or16 Name{};
     };
 
     enum class FGpuQueueType : u8
@@ -18,6 +18,7 @@ namespace Coplt
         Direct,
         Compute,
         Copy,
+        Video,
     };
 
     COPLT_INTERFACE_DEFINE(FGpuQueue, "95e60e28-e387-4055-9b33-2d23af901f8a", FGpuObject)
@@ -45,5 +46,10 @@ namespace Coplt
             void* hwnd,
             FGpuOutput** out
         ) noexcept = 0;
+
+        // 提交命令并等待执行器可用
+        virtual FResult Submit(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept = 0;
+        // 提交命令但是不等待执行器可用，必须先等待才能重新使用此执行器提交
+        virtual FResult SubmitNoWait(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept = 0;
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Resource.h b/Coplt.Graphics.Native/Api/FFI/Resource.h
index 68ce347..c9ddb94 100644
--- a/Coplt.Graphics.Native/Api/FFI/Resource.h
+++ b/Coplt.Graphics.Native/Api/FFI/Resource.h
@@ -45,16 +45,6 @@ namespace Coplt
         IndirectDrawArgs = 1 << 10,
     };
 
-    enum class FLifeTime : u8
-    {
-        // 一般资源
-        Common,
-        // 静态资源，一般比如静态加载的图片、材质的参数
-        Static,
-        // 瞬态资源，只在帧内使用，帧结束后将丢弃，同时每帧都会具有独立副本，类似交换链
-        Transient,
-    };
-
     enum class FCpuAccess : u8
     {
         None = 0,
@@ -72,20 +62,30 @@ namespace Coplt
         Raw,
     };
 
-    struct FGpuResourceCreateOptions
+    struct FGpuViewCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         FResourcePurpose Purpose{};
-        FCpuAccess CpuAccess{};
-        FLifeTime LifeTime{};
     };
 
-    COPLT_INTERFACE_DEFINE(FGpuResource, "f99dceec-2f0c-4a28-b666-beb7c35219d6", FGpuObject)
+    COPLT_INTERFACE_DEFINE(FGpuView, "b3aeb8a5-1fa6-4866-97ef-1a5fa401e18f", FGpuObject)
     {
-        FResourceState m_state{};
         FResourcePurpose m_purpose{};
+    };
+
+    struct FGpuResourceCreateOptions : FGpuViewCreateOptions
+    {
+        FCpuAccess CpuAccess{};
+    };
+
+    COPLT_INTERFACE_DEFINE(FGpuResource, "f99dceec-2f0c-4a28-b666-beb7c35219d6", FGpuView)
+    {
+        FResState m_state{};
         FCpuAccess m_cpu_access{};
-        FLifeTime m_life_time{};
+    };
+
+    COPLT_INTERFACE_DEFINE(FGpuTransientView, "f7dfc622-972b-49b2-8999-8fb129c61ac6", FGpuView)
+    {
     };
 
     struct FGpuBufferCreateOptions : FGpuResourceCreateOptions
@@ -112,6 +112,30 @@ namespace Coplt
         FBufferUsage m_usage{};
     };
 
+    struct FGpuUploadBufferCreateOptions : FGpuViewCreateOptions
+    {
+        // 字节大小
+        u64 Size{};
+        // 默认的 Structured Buffer 元素数量
+        u32 Count{};
+        // 默认的 Structured Buffer 元素步幅
+        u32 Stride{};
+        // 指示默认用法
+        FBufferUsage Usage{};
+    };
+
+    COPLT_INTERFACE_DEFINE(FGpuUploadBuffer, "3e85392d-8fd3-49eb-9872-cf7a0d7c8e4c", FGpuTransientView)
+    {
+        // 字节大小
+        u64 m_size{};
+        // 默认的 Structured Buffer 元素数量
+        u32 m_count{};
+        // 默认的 Structured Buffer 元素步幅
+        u32 m_stride{};
+        // 指示默认用法
+        FBufferUsage m_usage{};
+    };
+
     union FOptimizedClearColor
     {
         f32 Color[4];
@@ -186,4 +210,19 @@ namespace Coplt
         // 纹理布局
         FImageLayout m_layout{};
     };
+
+    enum class FViewType : u8
+    {
+        None,
+        Buffer,
+    };
+
+    struct FView
+    {
+        union
+        {
+            FGpuBuffer* Buffer;
+        };
+        FViewType Type;
+    };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Shader.h b/Coplt.Graphics.Native/Api/FFI/Shader.h
index a5371ad..ce254e0 100644
--- a/Coplt.Graphics.Native/Api/FFI/Shader.h
+++ b/Coplt.Graphics.Native/Api/FFI/Shader.h
@@ -14,7 +14,7 @@ namespace Coplt
         Task = 4,
     };
 
-    COPLT_ENUM_FLAGS(FShaderStageFlags, u8)
+    COPLT_ENUM_FLAGS(FShaderStageFlags, u32)
     {
         None = 0,
         Compute = 1 << 0,
@@ -26,7 +26,7 @@ namespace Coplt
 
     struct FShaderModuleCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         // 可选
         FString8* EntryPoint{};
         // 需要自己保证数据内容符合当前使用的后端，比如 dx 使用的 dxil，vk 使用的 spv
@@ -53,7 +53,7 @@ namespace Coplt
 
     struct FShaderCreateOptions
     {
-        Str8or16 Name{};
+        FStr8or16 Name{};
         // 此处是借用，不传递所有权
         FShaderLayout* Layout{};
         // 此处是借用，不传递所有权
diff --git a/Coplt.Graphics.Native/Api/FFI/States.h b/Coplt.Graphics.Native/Api/FFI/States.h
index f218663..182766b 100644
--- a/Coplt.Graphics.Native/Api/FFI/States.h
+++ b/Coplt.Graphics.Native/Api/FFI/States.h
@@ -1,11 +1,14 @@
 #pragma once
 
 #include "Common.h"
+#include "Layout.h"
 #include "Types.h"
 
 namespace Coplt
 {
-    COPLT_ENUM_FLAGS(FResourceState, u32)
+    #pragma region LegacyState
+
+    COPLT_ENUM_FLAGS(FLegacyState, u32)
     {
         // 手动管理资源状态，自动过渡时将忽略
         Manual = 0,
@@ -31,39 +34,142 @@ namespace Coplt
         GenericRead = VertexBuffer | ConstantBuffer | ShaderResource | IndirectBuffer | CopySrc,
     };
 
-#ifdef FFI_SRC
-    inline bool ContainsOnly(const FResourceState value, const FResourceState other)
+    #ifdef FFI_SRC
+
+    inline bool ContainsOnly(const FLegacyState value, const FLegacyState other)
     {
         return (value & ~other) == 0;
     }
 
-    inline bool Contains(const FResourceState value, const FResourceState other)
+    inline bool Contains(const FLegacyState value, const FLegacyState other)
     {
         return (value & other) != 0;
     }
 
-    inline bool IsReadOnly(const FResourceState value)
+    inline bool IsReadOnly(const FLegacyState value)
     {
         return ContainsOnly(
             value,
-            FResourceState::IndexBuffer | FResourceState::VertexBuffer |
-            FResourceState::ConstantBuffer | FResourceState::IndirectBuffer | FResourceState::CopySrc |
-            FResourceState::ResolveSrc | FResourceState::ShaderResource | FResourceState::DepthRead
+            FLegacyState::IndexBuffer | FLegacyState::VertexBuffer |
+            FLegacyState::ConstantBuffer | FLegacyState::IndirectBuffer | FLegacyState::CopySrc |
+            FLegacyState::ResolveSrc | FLegacyState::ShaderResource | FLegacyState::DepthRead
         );
     }
 
-    inline bool IsCompatible(const FResourceState value, const FResourceState other)
+    inline bool IsCompatible(const FLegacyState value, const FLegacyState other)
     {
-        if (value == FResourceState::Manual || other == FResourceState::Manual) return false;
-        if (value == other) return true;
-        if (IsReadOnly(value) && IsReadOnly(other)) return true;
+        if (value == FLegacyState::Manual || other == FLegacyState::Manual)
+            return false;
+        if (value == other)
+            return true;
+        if (IsReadOnly(value) && IsReadOnly(other))
+            return true;
         return false;
     }
 
-    inline FResourceState ChangeState(const FResourceState value, const FResourceState state)
+    inline FLegacyState ChangeState(const FLegacyState value, const FLegacyState state)
     {
-        if (IsCompatible(value, state)) return value | state;
+        if (IsCompatible(value, state))
+            return value | state;
         return state;
     }
-#endif
-};
+    #endif
+
+    #pragma endregion
+
+    enum class FResLayout: u32
+    {
+        None = 0,
+        Common,
+        Present = Common,
+        GenericRead,
+        RenderTarget,
+        UnorderedAccess,
+        DepthStencilRead,
+        DepthStencilWrite,
+        ShaderResource,
+        CopySrc,
+        CopyDst,
+        ResolveSrc,
+        ResolveDst,
+        ShadingRate,
+        VideoDecodeRead,
+        VideoDecodeWrite,
+        VideoProcessRead,
+        VideoProcessWrite,
+        VideoEncodeRead,
+        VideoEncodeWrite,
+    };
+
+    COPLT_ENUM_FLAGS(FResAccess, u32)
+    {
+        NoAccess = 1u << 31,
+        Common = 0,
+        ConstantBuffer = 1 << 0,
+        VertexBuffer = 1 << 1,
+        IndexBuffer = 1 << 2,
+        RenderTarget = 1 << 3,
+        UnorderedAccess = 1 << 4,
+        DepthStencilRead = 1 << 5,
+        DepthStencilWrite = 1 << 6,
+        ShaderResource = 1 << 7,
+        StreamOutput = 1 << 8,
+        IndirectOrPredicationBuffer = 1 << 9,
+        CopySrc = 1 << 10,
+        CopyDst = 1 << 11,
+        ResolveSrc = 1 << 12,
+        ResolveDst = 1 << 13,
+        RayTracingAccelerationStructureRead = 1 << 14,
+        RayTracingAccelerationStructureWrite = 1 << 15,
+        ShadingRate = 1 << 16,
+        VideoDecodeRead = 1 << 17,
+        VideoDecodeWrite = 1 << 18,
+        VideoProcessRead = 1 << 19,
+        VideoProcessWrite = 1 << 20,
+        VideoEncodeRead = 1 << 21,
+        VideoEncodeWrite = 1 << 22,
+    };
+
+    struct FResState
+    {
+        FResLayout Layout{};
+        FResAccess Access{};
+        FShaderStageFlags Stages{};
+        FLegacyState Legacy{};
+        b8 CrossQueue{};
+
+        #ifdef FFI_SRC
+
+        static FResState BufferCommon()
+        {
+            return FResState{
+                .Layout = FResLayout::None,
+                .Access = FResAccess::Common,
+                .Stages = FShaderStageFlags::None,
+                .Legacy = FLegacyState::Common,
+            };
+        }
+
+        static FResState BufferGenericRead()
+        {
+            return FResState{
+                .Layout = FResLayout::None,
+                .Access = FResAccess::Common,
+                .Stages = FShaderStageFlags::None,
+                .Legacy = FLegacyState::GenericRead,
+            };
+        }
+
+        static FResState BufferCopyDst()
+        {
+            return FResState{
+                .Layout = FResLayout::None,
+                .Access = FResAccess::CopyDst,
+                .Stages = FShaderStageFlags::None,
+                .Legacy = FLegacyState::CopyDst,
+            };
+        }
+
+        #endif
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/FFI/String.h b/Coplt.Graphics.Native/Api/FFI/String.h
index c00989f..637776d 100644
--- a/Coplt.Graphics.Native/Api/FFI/String.h
+++ b/Coplt.Graphics.Native/Api/FFI/String.h
@@ -8,11 +8,11 @@
 
 namespace Coplt
 {
-    struct Str8or16;
+    struct FStr8or16;
 
     COPLT_INTERFACE_DEFINE(FString, "5a478800-e7da-4a6b-b428-1e3fda55997f", FUnknown)
     {
-        virtual Str8or16 GetStr() const noexcept = 0;
+        virtual FStr8or16 GetStr() const noexcept = 0;
     };
 
     COPLT_INTERFACE_DEFINE(FString8, "63c7fc71-d775-42bb-891a-69dbb26e75c5", FString)
@@ -54,87 +54,108 @@ namespace Coplt
         FMessageType type;
     };
 
-    struct Str8
+    struct FStr8
     {
         const char* str;
         i32 len;
     };
 
-    struct Str16
+    struct FStr16
     {
         const Char16* str;
         i32 len;
     };
 
-    struct Str8or16
+    enum class FStrType : u8
     {
-        const char* str8;
-        const Char16* str16;
+        Str16,
+        Str8,
+    };
+
+    struct FStr8or16
+    {
+        union
+        {
+            const Char16* str16;
+            const char* str8;
+        };
+
         i32 len;
+        FStrType type;
 
 #ifdef FFI_SRC
-        Str8or16() = default;
+        FStr8or16() = default;
 
-        explicit Str8or16(const char* ptr, const usize len) : str8(ptr), str16(nullptr), len(len)
+        explicit FStr8or16(const char* ptr, const usize len)
+            : str8(ptr), len(static_cast<i32>(static_cast<u32>(len))), type(FStrType::Str8)
         {
         }
 
-        explicit Str8or16(const Char8* ptr, const usize len)
-            : str8(reinterpret_cast<const char*>(ptr)), str16(nullptr), len(len)
+        explicit FStr8or16(const Char8* ptr, const usize len)
+            : str8(reinterpret_cast<const char*>(ptr)),
+              len(static_cast<i32>(static_cast<u32>(len))), type(FStrType::Str8)
         {
         }
 
-        explicit Str8or16(const Char16* ptr, const usize len) : str8(nullptr), str16(ptr), len(len)
+        explicit FStr8or16(const Char16* ptr, const usize len)
+            : str16(ptr), len(static_cast<i32>(static_cast<u32>(len))), type(FStrType::Str16)
         {
         }
 
-        explicit Str8or16(const std::string& str) : str8(str.c_str()), str16(nullptr), len(str.length())
+        explicit FStr8or16(const std::string& str)
+            : str8(str.c_str()), len(static_cast<i32>(static_cast<u32>(str.length()))), type(FStrType::Str8)
         {
         }
 
         template <usize N>
-        explicit Str8or16(const char (&str)[N]) : str8(str), str16(nullptr), len(N)
+        explicit FStr8or16(const char (&str)[N])
+            : str8(str), len(static_cast<i32>(static_cast<u32>(N))), type(FStrType::Str8)
         {
         }
 
 #ifdef _WINDOWS
 
-        explicit Str8or16(const wchar_t* ptr, const usize len)
-            : str8(nullptr), str16(reinterpret_cast<const Char16*>(ptr)), len(len)
+        explicit FStr8or16(const wchar_t* ptr, const usize len)
+            : str16(reinterpret_cast<const Char16*>(ptr)),
+              len(static_cast<i32>(static_cast<u32>(len))), type(FStrType::Str16)
         {
         }
 
-        explicit Str8or16(const std::wstring& str)
-            : str8(nullptr), str16(reinterpret_cast<const Char16*>(str.c_str())), len(str.length())
+        explicit FStr8or16(const std::wstring& str)
+            : str16(reinterpret_cast<const Char16*>(str.c_str())),
+              len(static_cast<i32>(static_cast<u32>(str.length()))), type(FStrType::Str16)
         {
         }
 
         template <usize N>
-        explicit Str8or16(const wchar_t (&str)[N]) : str8(nullptr), str16(reinterpret_cast<const Char16*>(str)), len(N)
+        explicit FStr8or16(const wchar_t (&str)[N]) :
+            str16(reinterpret_cast<const Char16*>(str)),
+            len(static_cast<i32>(static_cast<u32>(N))), type(FStrType::Str16)
         {
         }
+
 #endif
 
-        bool has8() const
+        bool is8() const
         {
-            return str8 != nullptr;
+            return type == FStrType::Str8;
         }
 
-        bool has16() const
+        bool is16() const
         {
-            return str16 != nullptr;
+            return type == FStrType::Str16;
         }
 
         bool is_null() const
         {
-            return str8 == nullptr && str16 == nullptr;
+            return str16 == nullptr;
         }
 
         FString* ToString() const;
 #endif
     };
 
-    struct CStr8or16
+    struct FCStr8or16
     {
         const char* str8;
         const Char16* str16;
diff --git a/Coplt.Graphics.Native/Api/Include/ChunkedVector.h b/Coplt.Graphics.Native/Api/Include/ChunkedVector.h
new file mode 100644
index 0000000..96c4b22
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/Include/ChunkedVector.h
@@ -0,0 +1,152 @@
+#pragma once
+
+#include <vector>
+#include <bit>
+
+#include "Error.h"
+#include "mimalloc.h"
+
+namespace Coplt
+{
+    // 具有指针稳定性的分块 vector
+    template <class T>
+    class ChunkedVector
+    {
+        struct Chunk final
+        {
+            T* data{};
+            size_t size{};
+
+            Chunk() = default;
+
+            explicit Chunk(const size_t cap)
+            {
+                data = static_cast<T*>(mi_malloc_aligned(sizeof(T) * cap, alignof(T)));
+            }
+
+            Chunk(const Chunk&) = delete;
+            Chunk& operator=(const Chunk&) = delete;
+
+            Chunk(Chunk&& other) noexcept :
+                data(std::exchange(other.data, nullptr)),
+                size(std::exchange(other.size, 0))
+            {
+            }
+
+            Chunk& operator=(Chunk&& other) noexcept
+            {
+                Chunk(std::forward<Chunk>(other)).swap(*this);
+                return *this;
+            }
+
+            void swap(Chunk& other) noexcept
+            {
+                std::swap(data, other.data);
+                std::swap(size, other.size);
+            }
+
+            ~Chunk()
+            {
+                if (!data) return;
+                clear();
+                mi_free(data);
+            }
+
+            void clear()
+            {
+                if constexpr (!std::is_trivially_destructible_v<T>)
+                {
+                    for (size_t i = 0; i < size; ++i)
+                    {
+                        data[i].~T();
+                    }
+                }
+                size = 0;
+            }
+        };
+
+        std::vector<Chunk> m_chunks{};
+        size_t const m_chunk_size_mask{};
+        size_t const m_chunk_size_shift{};
+        size_t m_size{};
+
+    public:
+        constexpr static size_t DefaultChunkSize = 128;
+
+        ChunkedVector() : ChunkedVector(DefaultChunkSize)
+        {
+        }
+
+        explicit ChunkedVector(const size_t chunk_size)
+            : m_chunk_size_mask(chunk_size - 1), m_chunk_size_shift(std::countr_zero(chunk_size))
+        {
+            if (chunk_size < 2) throw std::invalid_argument("Chunk size must be greater than 2");
+            if (!std::has_single_bit(chunk_size)) throw std::invalid_argument("Chunk size must be a power of 2");
+        }
+
+        size_t size() const
+        {
+            return m_size;
+        }
+
+        T* at(const size_t index)
+        {
+            if (index >= m_size) throw std::out_of_range("Chunk index out of range");
+            auto chunk = index >> m_chunk_size_shift;
+            auto sub_index = index & m_chunk_size_mask;
+            return m_chunks[chunk].data + sub_index;
+        }
+
+        const T* at(const size_t index) const
+        {
+            if (index >= m_size) throw std::out_of_range("Chunk index out of range");
+            auto chunk = index >> m_chunk_size_shift;
+            auto sub_index = index & m_chunk_size_mask;
+            return m_chunks[chunk].data + sub_index;
+        }
+
+        T& operator[](const size_t index)
+        {
+            return *at(index);
+        }
+
+        T& operator[](const size_t index) const
+        {
+            return *at(index);
+        }
+
+        T* add(const T& value)
+        {
+            auto chunk_index = m_size >> m_chunk_size_shift;
+            if (chunk_index >= m_chunks.size()) m_chunks.push_back(Chunk(m_chunk_size_mask + 1));
+            auto& chunk = m_chunks[chunk_index];
+            auto ptr = chunk.data + chunk.size;
+            *ptr = value;
+            ++chunk.size;
+            ++m_size;
+            return ptr;
+        }
+
+        T* add(T&& value)
+        {
+            auto chunk_index = m_size >> m_chunk_size_shift;
+            if (chunk_index >= m_chunks.size()) m_chunks.push_back(Chunk(m_chunk_size_mask + 1));
+            auto& chunk = m_chunks[chunk_index];
+            auto ptr = chunk.data + chunk.size;
+            *ptr = std::forward<T>(value);
+            ++chunk.size;
+            ++m_size;
+            return ptr;
+        }
+
+        void clear()
+        {
+            const auto chunk_size = m_chunk_size_mask + 1;
+            for (size_t i = 0, c = 0; i < m_chunks.size(), c < m_size; ++i, c += chunk_size)
+            {
+                auto& chunk = m_chunks[i];
+                chunk.clear();
+            }
+        }
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/Include/Error.h b/Coplt.Graphics.Native/Api/Include/Error.h
index b5a4c43..33d868a 100644
--- a/Coplt.Graphics.Native/Api/Include/Error.h
+++ b/Coplt.Graphics.Native/Api/Include/Error.h
@@ -374,4 +374,12 @@ namespace Coplt
         }
         return r;
     }
+
+#ifdef _WINDOWS
+#define COPLT_THROW(msg) throw WRuntimeException(L##msg)
+#define COPLT_THROW_FMT(msg, ...) throw WRuntimeException(fmt::format(L##msg, __VA_ARGS__))
+#else
+#define COPLT_THROW(msg) throw RuntimeException(msg)
+#define COPLT_THROW_FMT(msg, ...) throw RuntimeException(fmt::format(msg, __VA_ARGS__))
+#endif
 }
diff --git a/Coplt.Graphics.Native/Api/Include/Object.h b/Coplt.Graphics.Native/Api/Include/Object.h
index 6894250..8c50f35 100644
--- a/Coplt.Graphics.Native/Api/Include/Object.h
+++ b/Coplt.Graphics.Native/Api/Include/Object.h
@@ -229,6 +229,16 @@ namespace Coplt
         {
             return get() == nullptr;
         }
+
+        bool operator==(T* ptr) const
+        {
+            return get() == ptr;
+        }
+
+        bool operator==(const T& ref) const
+        {
+            return *get() == ref;
+        }
     };
 
     template <class T>
@@ -438,10 +448,10 @@ namespace Coplt
         mutable std::atomic_size_t m_strong{1};
         mutable std::atomic_size_t m_weak{1};
 
-        COPLT_NO_INLINE void DropSlow(void* self, void* object_start, void (*free)(void*, void*)) const noexcept
+        COPLT_NO_INLINE void DropSlow(void* self, void* object_start, void (*p_free)(void*, void*)) const noexcept
         {
             this->~ObjectRcPartialImpl();
-            ReleaseWeak(self, object_start, free);
+            ReleaseWeak(self, object_start, p_free);
         }
 
         size_t AddRef() const noexcept
@@ -449,11 +459,11 @@ namespace Coplt
             return m_strong.fetch_add(1, std::memory_order_relaxed);
         }
 
-        size_t Release(void* self, void* object_start, void (*free)(void*, void*)) const noexcept
+        size_t Release(void* self, void* object_start, void (*p_free)(void*, void*)) const noexcept
         {
             const size_t r = m_strong.fetch_sub(1, std::memory_order_release);
             if (r != 1) return r;
-            DropSlow(self, object_start, free);
+            DropSlow(self, object_start, p_free);
             return r;
         }
 
@@ -462,11 +472,11 @@ namespace Coplt
             return m_weak.fetch_add(1, std::memory_order_relaxed);
         }
 
-        size_t ReleaseWeak(void* self, void* object_start, void (*free)(void*, void*)) const noexcept
+        size_t ReleaseWeak(void* self, void* object_start, void (*p_free)(void*, void*)) const noexcept
         {
             const size_t r = m_weak.fetch_sub(1, std::memory_order_release);
             if (r != 1) return r;
-            free(self, object_start);
+            p_free(self, object_start);
             return r;
         }
 
diff --git a/Coplt.Graphics.Native/Api/Src/Shader.cc b/Coplt.Graphics.Native/Api/Src/Shader.cc
index 7f0acd4..e398374 100644
--- a/Coplt.Graphics.Native/Api/Src/Shader.cc
+++ b/Coplt.Graphics.Native/Api/Src/Shader.cc
@@ -28,7 +28,7 @@ void ShaderModule::Free(void* self)
     mi_free_aligned(self, alignof(Self));
 }
 
-FResult ShaderModule::SetName(const Str8or16& name) noexcept
+FResult ShaderModule::SetName(const FStr8or16& name) noexcept
 {
     return FResult::None();
 }
@@ -43,59 +43,66 @@ Shader::Shader(Rc<FGpuDevice>&& device, const FShaderCreateOptions& options) : m
     m_layout = Rc<FShaderLayout>::UnsafeClone(options.Layout);
     m_input_layout = Rc<FShaderInputLayout>::UnsafeClone(options.InputLayout);
 
-    if (options.Count == 0) throw RuntimeException("options.Count cannot be 0");
+    if (options.Count == 0)
+        COPLT_THROW("options.Count cannot be 0");
     if (options.Count > MaxShaderModuleCount)
-        throw RuntimeException(
-            fmt::format("Too many shader modules, there can be a maximum of {}", MaxShaderModuleCount)
+    {
+        COPLT_THROW_FMT(
+            "Too many shader modules, there can be a maximum of {}", MaxShaderModuleCount
         );
-    if (options.Modules == nullptr) throw RuntimeException("options.Modules is null");
+    }
+    if (options.Modules == nullptr)
+        COPLT_THROW("options.Modules is null");
 
     for (u32 i = 0; i < options.Count; i++)
     {
         const auto module = options.Modules[i];
-        if (module == nullptr) throw RuntimeException(fmt::format("options.Modules[{}] is null", i));
+        if (module == nullptr)
+            COPLT_THROW_FMT("options.Modules[{}] is null", i);
         switch (module->Stage)
         {
         case FShaderStage::Compute:
-            if (options.Count != 1) throw RuntimeException("The compute stage cannot be combined with other stage");
+            if (options.Count != 1)
+                COPLT_THROW("The compute stage cannot be combined with other stage");
             Stages = FShaderStageFlags::Compute;
             m_modules[0] = Rc<FShaderModule>::UnsafeClone(module);
             return;
         case FShaderStage::Pixel:
-            if (options.Count == 1) throw RuntimeException("The pixel stage cannot exist alone");
+            if (options.Count == 1)
+                COPLT_THROW("The pixel stage cannot exist alone");
             Stages |= FShaderStageFlags::Pixel;
             m_modules[0] = Rc<FShaderModule>::UnsafeClone(module);
             break;
         case FShaderStage::Vertex:
             if (HasAnyFlags(Stages, FShaderStageFlags::Mesh | FShaderStageFlags::Task))
-                throw RuntimeException("The vertex stage and the mesh/task stage are mutually exclusive");
+                COPLT_THROW("The vertex stage and the mesh/task stage are mutually exclusive");
             Stages |= FShaderStageFlags::Vertex;
             m_modules[1] = Rc<FShaderModule>::UnsafeClone(module);
             break;
         case FShaderStage::Mesh:
             if (HasFlags(Stages, FShaderStageFlags::Vertex))
-                throw RuntimeException("The vertex stage and the mesh/task stage are mutually exclusive");
+                COPLT_THROW("The vertex stage and the mesh/task stage are mutually exclusive");
             Stages |= FShaderStageFlags::Mesh;
             m_modules[1] = Rc<FShaderModule>::UnsafeClone(module);
             break;
         case FShaderStage::Task:
             if (HasFlags(Stages, FShaderStageFlags::Vertex))
-                throw RuntimeException("The vertex stage and the mesh/task stage are mutually exclusive");
+                COPLT_THROW("The vertex stage and the mesh/task stage are mutually exclusive");
             Stages |= FShaderStageFlags::Task;
             m_modules[2] = Rc<FShaderModule>::UnsafeClone(module);
             break;
         default:
-            throw RuntimeException(
-                fmt::format("Unknown shader stage {}", static_cast<u32>(module->Stage))
+            COPLT_THROW_FMT(
+                "Unknown shader stage {}", static_cast<u32>(module->Stage)
             );
         }
     }
 
     if (HasFlags(Stages, FShaderStageFlags::Task) && !HasFlags(Stages, FShaderStageFlags::Mesh))
-        throw RuntimeException("Having a task stage must also have a mesh stage");
+        COPLT_THROW("Having a task stage must also have a mesh stage");
 }
 
-FResult Shader::SetName(const Str8or16& name) noexcept
+FResult Shader::SetName(const FStr8or16& name) noexcept
 {
     return FResult::None();
 }
diff --git a/Coplt.Graphics.Native/Api/Src/Shader.h b/Coplt.Graphics.Native/Api/Src/Shader.h
index 03e6b18..fafc575 100644
--- a/Coplt.Graphics.Native/Api/Src/Shader.h
+++ b/Coplt.Graphics.Native/Api/Src/Shader.h
@@ -22,7 +22,7 @@ namespace Coplt
 
         void Free(void* self) override;
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         // 可空
         FString8* GetEntryPoint() noexcept override;
@@ -40,7 +40,7 @@ namespace Coplt
 
         explicit Shader(Rc<FGpuDevice>&& device, const FShaderCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         FShaderLayout* Layout() noexcept override;
 
diff --git a/Coplt.Graphics.Native/Api/Src/String.cc b/Coplt.Graphics.Native/Api/Src/String.cc
index 3d1ea40..8112967 100644
--- a/Coplt.Graphics.Native/Api/Src/String.cc
+++ b/Coplt.Graphics.Native/Api/Src/String.cc
@@ -2,9 +2,14 @@
 
 using namespace Coplt;
 
-FString* Str8or16::ToString() const
+FString* FStr8or16::ToString() const
 {
-    if (has16()) return String16::Create(str16, len);
-    if (has8()) return String8::Create(str8, len);
+    switch (type)
+    {
+    case FStrType::Str16:
+        return String16::Create(str16, len);
+    case FStrType::Str8:
+        return String8::Create(str8, len);
+    }
     return nullptr;
 }
diff --git a/Coplt.Graphics.Native/Api/Src/String.h b/Coplt.Graphics.Native/Api/Src/String.h
index 90ad662..8f7a374 100644
--- a/Coplt.Graphics.Native/Api/Src/String.h
+++ b/Coplt.Graphics.Native/Api/Src/String.h
@@ -151,9 +151,9 @@ namespace Coplt
             return std::string(c_str(), m_size);
         }
 
-        Str8or16 GetStr() const noexcept override
+        FStr8or16 GetStr() const noexcept override
         {
-            return Str8or16(c_str(), size());
+            return FStr8or16(c_str(), size());
         }
     };
 
@@ -199,9 +199,9 @@ namespace Coplt
         }
 #endif
 
-        Str8or16 GetStr() const noexcept override
+        FStr8or16 GetStr() const noexcept override
         {
-            return Str8or16(data(), size());
+            return FStr8or16(data(), size());
         }
     };
 
@@ -216,9 +216,9 @@ namespace Coplt
         {
         }
 
-        Str8or16 GetStr() const noexcept override
+        FStr8or16 GetStr() const noexcept override
         {
-            return Str8or16(data(), size());
+            return FStr8or16(data(), size());
         }
     };
 
@@ -234,9 +234,9 @@ namespace Coplt
         {
         }
 
-        Str8or16 GetStr() const noexcept override
+        FStr8or16 GetStr() const noexcept override
         {
-            return Str8or16(data(), size());
+            return FStr8or16(data(), size());
         }
     };
 #endif
diff --git a/Coplt.Graphics.Native/D3d12/CMakeLists.txt b/Coplt.Graphics.Native/D3d12/CMakeLists.txt
index 2e09304..3b0f42c 100644
--- a/Coplt.Graphics.Native/D3d12/CMakeLists.txt
+++ b/Coplt.Graphics.Native/D3d12/CMakeLists.txt
@@ -37,11 +37,22 @@ add_library(${target_name} SHARED
     Src/Context.h
     Src/Context.cc
     Include/States.h
+    FFI/Binding.h
+    Src/Binding.h
+    Src/Binding.cc
+    Src/DescriptorManager.h
+    Src/DescriptorManager.cc
+    Include/View.h
+    Src/Executor.h
+    FFI/Adapter.h
+    Src/Adapter.h
+    Src/Adapter.cc
 )
 set_target_properties(${target_name} PROPERTIES LINKER_LANGUAGE CXX)
 set_target_properties(${target_name} PROPERTIES OUTPUT_NAME "Coplt.Graphics.Native.D3d12")
 add_library(Coplt::Graphics::D3d12 ALIAS ${target_name})
-target_compile_definitions(${target_name} PRIVATE -DFFI_SRC -DNOMINMAX)
+target_compile_definitions(${target_name} PRIVATE -DFFI_SRC -DNOMINMAX -DUSE_PIX)
+target_include_directories(${target_name} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime)
 
 set(BUILD_XAUDIO_WIN10 OFF)
 set(BUILD_DXIL_SHADERS OFF)
@@ -55,3 +66,8 @@ target_link_libraries(${target_name}
     Microsoft::DirectX-Headers
     D3D12MemoryAllocator
 )
+
+target_link_libraries(${target_name}
+    PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib
+)
diff --git a/Coplt.Graphics.Native/D3d12/FFI/Adapter.h b/Coplt.Graphics.Native/D3d12/FFI/Adapter.h
new file mode 100644
index 0000000..fd8ee22
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/FFI/Adapter.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "../../Api/FFI/Adapter.h"
+
+namespace Coplt
+{
+    COPLT_INTERFACE_DEFINE(FD3d12GpuAdapter, "a3d7c62d-7cfd-42c1-af7a-781170046ca5", FGpuAdapter)
+    {
+
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/FFI/Binding.h b/Coplt.Graphics.Native/D3d12/FFI/Binding.h
new file mode 100644
index 0000000..92a58a8
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/FFI/Binding.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "../../Api/FFI/Binding.h"
+
+namespace Coplt
+{
+    COPLT_INTERFACE_DEFINE(FD3d12ShaderBinding, "aace0f36-a59e-45ea-88c7-7807d20d2750", FShaderBinding)
+    {
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/FFI/Library.h b/Coplt.Graphics.Native/D3d12/FFI/Library.h
index afe12fe..66fcadd 100644
--- a/Coplt.Graphics.Native/D3d12/FFI/Library.h
+++ b/Coplt.Graphics.Native/D3d12/FFI/Library.h
@@ -2,4 +2,4 @@
 
 #include "../../Api/FFI/Instance.h"
 
-extern "C" COPLT_API Coplt::FInstance* Coplt_Graphics_D3d12_Create_Instance();
+extern "C" COPLT_API void Coplt_Graphics_D3d12_Create_Instance(Coplt::FResult* r, const Coplt::FInstanceCreateOptions& options, Coplt::FInstance** out);
diff --git a/Coplt.Graphics.Native/D3d12/Include/PipelineState.h b/Coplt.Graphics.Native/D3d12/Include/PipelineState.h
index 43bc03b..c30c924 100644
--- a/Coplt.Graphics.Native/D3d12/Include/PipelineState.h
+++ b/Coplt.Graphics.Native/D3d12/Include/PipelineState.h
@@ -236,4 +236,24 @@ namespace Coplt
             return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
         }
     }
+
+    inline D3D12_RESOLVE_MODE ToDx(const FResolveMode value)
+    {
+        switch (value)
+        {
+        case FResolveMode::Decompress:
+            return D3D12_RESOLVE_MODE_DECOMPRESS;
+            break;
+        case FResolveMode::Min:
+            return D3D12_RESOLVE_MODE_MIN;
+            break;
+        case FResolveMode::Max:
+            return D3D12_RESOLVE_MODE_MAX;
+            break;
+        case FResolveMode::Average:
+            return D3D12_RESOLVE_MODE_AVERAGE;
+            break;
+        }
+        return D3D12_RESOLVE_MODE_DECOMPRESS;
+    }
 }
diff --git a/Coplt.Graphics.Native/D3d12/Include/States.h b/Coplt.Graphics.Native/D3d12/Include/States.h
index 6c7a10b..2f3b210 100644
--- a/Coplt.Graphics.Native/D3d12/Include/States.h
+++ b/Coplt.Graphics.Native/D3d12/Include/States.h
@@ -2,6 +2,8 @@
 
 #include <directx/d3d12.h>
 
+#include "../../Api/FFI/Queue.h"
+
 namespace Coplt
 {
     constexpr D3D12_RESOURCE_STATES AllReadStates =
@@ -36,41 +38,308 @@ namespace Coplt
         return state;
     }
 
-    inline D3D12_RESOURCE_STATES ToDx(const FResourceState state)
+    inline D3D12_RESOURCE_STATES ToDx(const FLegacyState state)
     {
         switch (state)
         {
-        case FResourceState::Common:
-        case FResourceState::Present:
+        case FLegacyState::Common:
+        case FLegacyState::Present:
             return D3D12_RESOURCE_STATE_COMMON;
-        case FResourceState::RenderTarget:
+        case FLegacyState::RenderTarget:
             return D3D12_RESOURCE_STATE_RENDER_TARGET;
-        case FResourceState::DepthWrite:
+        case FLegacyState::DepthWrite:
             return D3D12_RESOURCE_STATE_DEPTH_WRITE;
-        case FResourceState::UnorderedAccess:
+        case FLegacyState::UnorderedAccess:
             return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
-        case FResourceState::CopyDst:
+        case FLegacyState::CopyDst:
             return D3D12_RESOURCE_STATE_COPY_DEST;
-        case FResourceState::ResolveDst:
+        case FLegacyState::ResolveDst:
             return D3D12_RESOURCE_STATE_RESOLVE_DEST;
-        case FResourceState::RayTracing:
+        case FLegacyState::RayTracing:
             return D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE;
-        case FResourceState::ShadingRate:
+        case FLegacyState::ShadingRate:
             return D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE;
-        case FResourceState::StreamOutput:
+        case FLegacyState::StreamOutput:
             return D3D12_RESOURCE_STATE_STREAM_OUT;
         default:
             break;
         }
         D3D12_RESOURCE_STATES r = D3D12_RESOURCE_STATE_COMMON;
-        if (HasAnyFlags(state, FResourceState::ConstantBuffer | FResourceState::VertexBuffer))
+        if (HasAnyFlags(state, FLegacyState::ConstantBuffer | FLegacyState::VertexBuffer))
             r |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
-        if (HasFlags(state, FResourceState::IndexBuffer)) r |= D3D12_RESOURCE_STATE_INDEX_BUFFER;
-        if (HasFlags(state, FResourceState::IndirectBuffer)) r |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
-        if (HasFlags(state, FResourceState::DepthRead)) r |= D3D12_RESOURCE_STATE_DEPTH_READ;
-        if (HasFlags(state, FResourceState::ShaderResource)) r |= D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE;
-        if (HasFlags(state, FResourceState::CopySrc)) r |= D3D12_RESOURCE_STATE_COPY_SOURCE;
-        if (HasFlags(state, FResourceState::ResolveSrc)) r |= D3D12_RESOURCE_STATE_RESOLVE_SOURCE;
+        if (HasFlags(state, FLegacyState::IndexBuffer)) r |= D3D12_RESOURCE_STATE_INDEX_BUFFER;
+        if (HasFlags(state, FLegacyState::IndirectBuffer)) r |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
+        if (HasFlags(state, FLegacyState::DepthRead)) r |= D3D12_RESOURCE_STATE_DEPTH_READ;
+        if (HasFlags(state, FLegacyState::ShaderResource)) r |= D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE;
+        if (HasFlags(state, FLegacyState::CopySrc)) r |= D3D12_RESOURCE_STATE_COPY_SOURCE;
+        if (HasFlags(state, FLegacyState::ResolveSrc)) r |= D3D12_RESOURCE_STATE_RESOLVE_SOURCE;
+        return r;
+    }
+
+    inline D3D12_BARRIER_LAYOUT ToDx(const FResLayout value, const std::optional<FGpuQueueType> queue)
+    {
+        if (queue.has_value())
+        {
+            switch (queue.value())
+            {
+            case FGpuQueueType::Direct:
+                switch (value)
+                {
+                case FResLayout::Common:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON;
+                case FResLayout::GenericRead:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ;
+                case FResLayout::UnorderedAccess:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS;
+                case FResLayout::ShaderResource:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE;
+                case FResLayout::CopySrc:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE;
+                case FResLayout::CopyDst:
+                    return D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST;
+                default:
+                    break;
+                }
+                break;
+            case FGpuQueueType::Compute:
+                switch (value)
+                {
+                case FResLayout::Common:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON;
+                case FResLayout::GenericRead:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ;
+                case FResLayout::UnorderedAccess:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS;
+                case FResLayout::ShaderResource:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE;
+                case FResLayout::CopySrc:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE;
+                case FResLayout::CopyDst:
+                    return D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST;
+                default:
+                    break;
+                }
+                break;
+            case FGpuQueueType::Copy:
+                break;
+            case FGpuQueueType::Video:
+                switch (value)
+                {
+                case FResLayout::Common:
+                    return D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON;
+                default:
+                    break;
+                }
+                break;
+            }
+        }
+        switch (value)
+        {
+        case FResLayout::None:
+            return D3D12_BARRIER_LAYOUT_UNDEFINED;
+        case FResLayout::Common:
+            return D3D12_BARRIER_LAYOUT_COMMON;
+        case FResLayout::GenericRead:
+            return D3D12_BARRIER_LAYOUT_GENERIC_READ;
+        case FResLayout::RenderTarget:
+            return D3D12_BARRIER_LAYOUT_RENDER_TARGET;
+        case FResLayout::UnorderedAccess:
+            return D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS;
+        case FResLayout::DepthStencilRead:
+            return D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ;
+        case FResLayout::DepthStencilWrite:
+            return D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE;
+        case FResLayout::ShaderResource:
+            return D3D12_BARRIER_LAYOUT_SHADER_RESOURCE;
+        case FResLayout::CopySrc:
+            return D3D12_BARRIER_LAYOUT_COPY_SOURCE;
+        case FResLayout::CopyDst:
+            return D3D12_BARRIER_LAYOUT_COPY_DEST;
+        case FResLayout::ResolveSrc:
+            return D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE;
+        case FResLayout::ResolveDst:
+            return D3D12_BARRIER_LAYOUT_RESOLVE_DEST;
+        case FResLayout::ShadingRate:
+            return D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE;
+        case FResLayout::VideoDecodeRead:
+            return D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ;
+        case FResLayout::VideoDecodeWrite:
+            return D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE;
+        case FResLayout::VideoProcessRead:
+            return D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ;
+        case FResLayout::VideoProcessWrite:
+            return D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE;
+        case FResLayout::VideoEncodeRead:
+            return D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ;
+        case FResLayout::VideoEncodeWrite:
+            return D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE;
+        }
+        return D3D12_BARRIER_LAYOUT_UNDEFINED;
+    }
+
+    inline D3D12_BARRIER_ACCESS ToDx(const FResAccess value)
+    {
+        if (HasFlags(value, FResAccess::NoAccess)) return D3D12_BARRIER_ACCESS_NO_ACCESS;
+        D3D12_BARRIER_ACCESS r = D3D12_BARRIER_ACCESS_COMMON;
+        if (HasFlags(value, FResAccess::ConstantBuffer)) r |= D3D12_BARRIER_ACCESS_CONSTANT_BUFFER;
+        if (HasFlags(value, FResAccess::VertexBuffer)) r |= D3D12_BARRIER_ACCESS_VERTEX_BUFFER;
+        if (HasFlags(value, FResAccess::IndexBuffer)) r |= D3D12_BARRIER_ACCESS_INDEX_BUFFER;
+        if (HasFlags(value, FResAccess::RenderTarget)) r |= D3D12_BARRIER_ACCESS_RENDER_TARGET;
+        if (HasFlags(value, FResAccess::UnorderedAccess)) r |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS;
+        if (HasFlags(value, FResAccess::DepthStencilRead)) r |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ;
+        if (HasFlags(value, FResAccess::DepthStencilWrite)) r |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE;
+        if (HasFlags(value, FResAccess::ShaderResource)) r |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE;
+        if (HasFlags(value, FResAccess::StreamOutput)) r |= D3D12_BARRIER_ACCESS_STREAM_OUTPUT;
+        if (HasFlags(value, FResAccess::IndirectOrPredicationBuffer)) r |= D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT;
+        if (HasFlags(value, FResAccess::CopySrc)) r |= D3D12_BARRIER_ACCESS_COPY_SOURCE;
+        if (HasFlags(value, FResAccess::CopyDst)) r |= D3D12_BARRIER_ACCESS_COPY_DEST;
+        if (HasFlags(value, FResAccess::ResolveSrc)) r |= D3D12_BARRIER_ACCESS_RESOLVE_SOURCE;
+        if (HasFlags(value, FResAccess::ResolveDst)) r |= D3D12_BARRIER_ACCESS_RESOLVE_DEST;
+        if (HasFlags(value, FResAccess::RayTracingAccelerationStructureRead)) r |= D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ;
+        if (HasFlags(value, FResAccess::RayTracingAccelerationStructureWrite)) r |= D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE;
+        if (HasFlags(value, FResAccess::ShadingRate)) r |= D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE;
+        if (HasFlags(value, FResAccess::VideoDecodeRead)) r |= D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ;
+        if (HasFlags(value, FResAccess::VideoDecodeWrite)) r |= D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE;
+        if (HasFlags(value, FResAccess::VideoProcessRead)) r |= D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ;
+        if (HasFlags(value, FResAccess::VideoProcessWrite)) r |= D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE;
+        if (HasFlags(value, FResAccess::VideoEncodeRead)) r |= D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ;
+        if (HasFlags(value, FResAccess::VideoEncodeWrite)) r |= D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE;
+        return r;
+    }
+
+    inline bool Diff(const FResAccess self, const FResAccess other, const FResAccess cmp)
+    {
+        return (self & ~other & cmp) != 0;
+    }
+
+    inline D3D12_BARRIER_SYNC CalcSync(
+        const FShaderStageFlags stages,
+        const FResAccess access,
+        const FResAccess access2
+    )
+    {
+        if (access == FResAccess::Common) return D3D12_BARRIER_SYNC_ALL;
+        if (HasFlags(access, FResAccess::NoAccess)) return D3D12_BARRIER_SYNC_NONE;
+
+        D3D12_BARRIER_SYNC r = D3D12_BARRIER_SYNC_NONE;
+
+        constexpr auto ib_acc = FResAccess::IndexBuffer;
+        if (Diff(access, access2, ib_acc))
+            r |= D3D12_BARRIER_SYNC_INDEX_INPUT;
+
+        constexpr auto vs_acc = FResAccess::VertexBuffer | FResAccess::ConstantBuffer
+            | FResAccess::UnorderedAccess | FResAccess::ShaderResource | FResAccess::StreamOutput;
+        if (
+            Diff(access, access2, vs_acc)
+            && HasAnyFlags(stages, FShaderStageFlags::Vertex | FShaderStageFlags::Mesh | FShaderStageFlags::Task)
+        )
+            r |= D3D12_BARRIER_SYNC_VERTEX_SHADING;
+
+        constexpr auto ps_acc = FResAccess::ConstantBuffer | FResAccess::UnorderedAccess
+            | FResAccess::ShadingRate | FResAccess::ShaderResource;
+        if (
+            Diff(access, access2, ps_acc)
+            && HasAnyFlags(stages, FShaderStageFlags::Pixel)
+        )
+            r |= D3D12_BARRIER_SYNC_PIXEL_SHADING;
+
+        constexpr auto ds_acc = FResAccess::DepthStencilRead | FResAccess::DepthStencilWrite;
+        if (Diff(access, access2, ds_acc))
+            r |= D3D12_BARRIER_SYNC_DEPTH_STENCIL;
+
+        constexpr auto rt_acc = FResAccess::RenderTarget;
+        if (Diff(access, access2, rt_acc))
+            r |= D3D12_BARRIER_SYNC_RENDER_TARGET;
+
+        constexpr auto cs_acc = FResAccess::RenderTarget;
+        if (
+            Diff(access, access2, cs_acc)
+            && HasAnyFlags(stages, FShaderStageFlags::Compute)
+        )
+            r |= D3D12_BARRIER_SYNC_COMPUTE_SHADING;
+
+        constexpr auto ray_acc = FResAccess::RayTracingAccelerationStructureRead | FResAccess::RayTracingAccelerationStructureWrite;
+        if (Diff(access, access2, ray_acc))
+            r |= D3D12_BARRIER_SYNC_RAYTRACING;
+
+        constexpr auto copy_acc = FResAccess::CopySrc | FResAccess::CopyDst;
+        if (Diff(access, access2, copy_acc))
+            r |= D3D12_BARRIER_SYNC_COPY;
+
+        constexpr auto resolve_acc = FResAccess::ResolveSrc | FResAccess::ResolveDst;
+        if (Diff(access, access2, resolve_acc))
+            r |= D3D12_BARRIER_SYNC_RESOLVE;
+
+        constexpr auto ind_acc = FResAccess::IndirectOrPredicationBuffer;
+        if (Diff(access, access2, ind_acc))
+            r |= D3D12_BARRIER_SYNC_EXECUTE_INDIRECT;
+
+        constexpr auto vd_acc = FResAccess::VideoDecodeRead | FResAccess::VideoDecodeWrite;
+        if (Diff(access, access2, vd_acc))
+            r |= D3D12_BARRIER_SYNC_VIDEO_DECODE;
+
+        constexpr auto vp_acc = FResAccess::VideoProcessRead | FResAccess::VideoProcessWrite;
+        if (Diff(access, access2, vp_acc))
+            r |= D3D12_BARRIER_SYNC_VIDEO_PROCESS;
+
+        constexpr auto ve_acc = FResAccess::VideoEncodeRead | FResAccess::VideoEncodeWrite;
+        if (Diff(access, access2, ve_acc))
+            r |= D3D12_BARRIER_SYNC_VIDEO_ENCODE;
+
+        constexpr auto ray_build_acc = FResAccess::RayTracingAccelerationStructureRead;
+        if (Diff(access, access2, ray_build_acc))
+            r |= D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE | D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE;
+
+        constexpr auto clear_uav_acc = FResAccess::UnorderedAccess;
+        if (Diff(access, access2, clear_uav_acc))
+            r |= D3D12_BARRIER_SYNC_CLEAR_UNORDERED_ACCESS_VIEW;
+
         return r;
     }
+
+    template<Fn<void, D3D12_CLEAR_VALUE&> F>
+    inline D3D12_RENDER_PASS_BEGINNING_ACCESS ToDx(const FLoadOp load, F SetClearValue)
+    {
+        D3D12_RENDER_PASS_BEGINNING_ACCESS acc{};
+        switch (load)
+        {
+        case FLoadOp::Load:
+            acc.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE;
+            break;
+        case FLoadOp::Clear:
+            acc.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR;
+            SetClearValue(acc.Clear.ClearValue);
+            break;
+        case FLoadOp::Discard:
+            acc.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD;
+            break;
+        case FLoadOp::NoAccess:
+            acc.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS;
+            break;
+        }
+        return acc;
+    }
+
+    template<Fn<void, D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS&> F>
+    D3D12_RENDER_PASS_ENDING_ACCESS ToDx(const FStoreOp store, F SetResolve)
+    {
+        D3D12_RENDER_PASS_ENDING_ACCESS acc{};
+        switch (store)
+        {
+        case FStoreOp::Store:
+            acc.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE;
+            break;
+        case FStoreOp::Discard:
+            acc.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD;
+            break;
+        case FStoreOp::Resolve:
+            acc.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE;
+            SetResolve(acc.Resolve);
+            break;
+        case FStoreOp::NoAccess:
+            acc.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS;
+            break;
+        }
+        return acc;
+    }
 }
diff --git a/Coplt.Graphics.Native/D3d12/Include/Utils.h b/Coplt.Graphics.Native/D3d12/Include/Utils.h
index 3957a54..b09fecd 100644
--- a/Coplt.Graphics.Native/D3d12/Include/Utils.h
+++ b/Coplt.Graphics.Native/D3d12/Include/Utils.h
@@ -53,7 +53,7 @@ namespace Coplt
         T str;
     };
 
-    inline auto SetNameEx(const Str8or16& str)
+    inline auto SetNameEx(const FStr8or16& str)
     {
         return SetName_t{&str};
     }
@@ -64,14 +64,13 @@ namespace Coplt
         return obj.Get() >> arg;
     }
 
-    inline HRESULT operator >>(ID3D12Object* obj, const SetName_t<const Str8or16*> arg)
+    inline HRESULT operator >>(ID3D12Object* obj, const SetName_t<const FStr8or16*> arg)
     {
-        if (arg.str->has16())
+        switch (arg.str->type)
         {
+        case FStrType::Str16:
             return obj->SetPrivateData(WKPDID_D3DDebugObjectNameW, static_cast<UINT>(arg.str->len * 2), arg.str->str16);
-        }
-        else if (arg.str->has8())
-        {
+        case FStrType::Str8:
             return obj->SetPrivateData(WKPDID_D3DDebugObjectName, static_cast<UINT>(arg.str->len), arg.str->str8);
         }
         return S_OK;
diff --git a/Coplt.Graphics.Native/D3d12/Include/View.h b/Coplt.Graphics.Native/D3d12/Include/View.h
new file mode 100644
index 0000000..2ac5adb
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Include/View.h
@@ -0,0 +1,135 @@
+#pragma once
+
+#include <variant>
+
+#include "../../Api/FFI/Resource.h"
+#include "../Src/Buffer.h"
+
+namespace Coplt
+{
+    struct View
+    {
+        enum class Type : u8
+        {
+            None,
+            Buffer,
+        };
+
+    private:
+        union
+        {
+            Rc<D3d12GpuBuffer> m_buffer;
+        };
+
+        Type m_type;
+
+    public:
+        Type Type() const { return m_type; }
+        Rc<D3d12GpuBuffer>* Buffer() { return m_type == Type::Buffer ? std::addressof(m_buffer) : nullptr; }
+
+        ~View()
+        {
+            // ReSharper disable once CppDefaultCaseNotHandledInSwitchStatement
+            switch (m_type)
+            {
+            case Type::None:
+                return;
+            case Type::Buffer:
+                m_buffer.~Rc();
+                return;
+            }
+            std::unreachable();
+        }
+
+        View() : m_type(Type::None)
+        {
+        }
+
+        View(const View& other) : m_type(other.m_type)
+        {
+            switch (m_type)
+            {
+            case Type::None:
+                break;
+            case Type::Buffer:
+                new(std::addressof(m_buffer)) Rc(other.m_buffer);
+                break;
+            }
+        }
+
+        View(View&& other) noexcept : m_type(std::exchange(other.m_type, Type::None))
+        {
+            switch (m_type)
+            {
+            case Type::None:
+                break;
+            case Type::Buffer:
+                new(std::addressof(m_buffer)) Rc(std::move(other.m_buffer));
+                break;
+            }
+        }
+
+        View& operator=(const View& view) noexcept
+        {
+            this->~View();
+            new(this) View(view);
+            return *this;
+        }
+
+        View& operator=(View&& view) noexcept
+        {
+            this->~View();
+            new(this) View(std::forward<View>(view));
+            return *this;
+        }
+
+        View(const FView& view)
+        {
+            switch (view.Type)
+            {
+            case FViewType::None:
+                m_type = Type::None;
+                break;
+            case FViewType::Buffer:
+                m_type = Type::Buffer;
+                if (view.Buffer == nullptr) new(std::addressof(m_buffer)) Rc<D3d12GpuBuffer>();
+                const auto db = view.Buffer->QueryInterface<D3d12GpuBuffer>();
+                if (db == nullptr)
+                    COPLT_THROW("GpuBuffer from different backends.");
+                new(std::addressof(m_buffer)) Rc(Rc<D3d12GpuBuffer>::UnsafeClone(db));
+                break;
+            }
+        }
+
+        View& operator=(const FView& view)
+        {
+            this->~View();
+            new(this) View(view);
+            return *this;
+        }
+
+        View(const Rc<D3d12GpuBuffer>& buffer) : m_type(Type::Buffer)
+        {
+            new(std::addressof(m_buffer)) Rc(buffer);
+        }
+
+        View(Rc<D3d12GpuBuffer>&& buffer) : m_type(Type::Buffer)
+        {
+            new(std::addressof(m_buffer)) Rc(std::move(buffer));
+        }
+
+        View& operator=(const Rc<D3d12GpuBuffer>& buffer)
+        {
+            this->~View();
+            new(this) View(buffer);
+            return *this;
+        }
+
+        View& operator=(Rc<D3d12GpuBuffer>&& buffer)
+        {
+            this->~View();
+            new(this) View(std::forward<Rc<D3d12GpuBuffer>>(buffer));
+            return *this;
+        }
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Adapter.cc b/Coplt.Graphics.Native/D3d12/Src/Adapter.cc
new file mode 100644
index 0000000..40856c7
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/Adapter.cc
@@ -0,0 +1,112 @@
+#include "Adapter.h"
+
+#include "directx/d3d12.h"
+#include "directx/d3dx12_check_feature_support.h"
+
+#include "../../Api/Include/Error.h"
+
+using namespace Coplt;
+
+D3d12GpuAdapter::D3d12GpuAdapter(
+    Rc<D3d12Instance>&& instance, ComPtr<IDXGIAdapter1>&& adapter
+): m_instance(std::move(instance)), m_adapter(std::move(adapter))
+{
+    m_backend = FBackend::Dx12;
+
+    ComPtr<ID3D12Device> device{};
+    chr | D3D12CreateDevice(m_adapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&device));
+
+    CD3DX12FeatureSupport feature_support{};
+    chr | feature_support.Init(device.Get());
+
+    m_d3d_feature_level = static_cast<FD3dFeatureLevel>(feature_support.MaxSupportedFeatureLevel());
+
+    DXGI_ADAPTER_DESC1 desc1{};
+    chr | m_adapter->GetDesc1(&desc1);
+    m_name_string = std::wstring(desc1.Description);
+    m_name = FStr8or16(m_name_string);
+    m_vendor_id = desc1.VendorId;
+    m_device_id = desc1.DeviceId;
+
+    if (desc1.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
+    {
+        m_device_type = FDeviceType::Cpu;
+    }
+    else if (feature_support.UMA())
+    {
+        m_device_type = FDeviceType::IntegratedGpu;
+    }
+    else
+    {
+        m_device_type = FDeviceType::DiscreteGpu;
+    }
+
+    LARGE_INTEGER li{};
+    if (SUCCEEDED(m_adapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &li)))
+    {
+        const auto i = li.QuadPart;
+        m_driver_string = fmt::format(L"{}.{}.{}.{}", i >> 48, (i >> 32) & 0xFFFF, (i >> 16) & 0xFFFF, i & 0xFFFF);
+        m_driver = FStr8or16(m_driver_string);
+    }
+
+    m_features.DescriptorHeap = true;
+    m_features.ArrBindless = true;
+
+    m_features.ShaderModelLevel = static_cast<FShaderModelLevel>(feature_support.HighestShaderModel());
+    if (m_features.ShaderModelLevel >= FShaderModelLevel::SM_6_6)
+    {
+        m_features.DynBindless = true;
+    }
+
+    if (feature_support.RaytracingTier() >= D3D12_RAYTRACING_TIER_1_0) m_features.RayTracing = true;
+    if (feature_support.MeshShaderTier() >= D3D12_MESH_SHADER_TIER_1) m_features.MeshShader = true;
+    if (feature_support.EnhancedBarriersSupported()) m_features.EnhancedBarriers = true;
+}
+
+FResult D3d12GpuAdapter::CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept
+{
+    return feb([&]
+    {
+        *out = new D3d12GpuDevice(this->CloneThis(), options);
+    });
+}
+
+b8 D3d12GpuAdapter::IsSupport(const FDeviceRequires& Requires) noexcept
+{
+    switch (Requires.DeviceType)
+    {
+    case FDeviceTypeRequire::Any:
+        break;
+    case FDeviceTypeRequire::Gpu:
+    case FDeviceTypeRequire::VirtualGpu:
+        if (m_device_type != FDeviceType::DiscreteGpu && m_device_type != FDeviceType::IntegratedGpu) return false;
+    case FDeviceTypeRequire::IntegratedGpu:
+        if (m_device_type != FDeviceType::IntegratedGpu) return false;
+        break;
+    case FDeviceTypeRequire::DiscreteGpu:
+        if (m_device_type != FDeviceType::DiscreteGpu) return false;
+        break;
+    case FDeviceTypeRequire::Cpu:
+        if (m_device_type != FDeviceType::Cpu) return false;
+        break;
+    default:
+        return false;
+    }
+    if (Requires.D3dFeatureLevel > m_d3d_feature_level)
+        return false;
+    if (Requires.FeatureRequires.ShaderModelLevel > m_features.ShaderModelLevel)
+        return false;
+    if (Requires.FeatureRequires.RayTracing && !m_features.RayTracing)
+        return false;
+    if (Requires.FeatureRequires.MeshShader && !m_features.MeshShader)
+        return false;
+    if (Requires.FeatureRequires.DescriptorHeap && !m_features.DescriptorHeap)
+        return false;
+    if (Requires.FeatureRequires.EnhancedBarriers && !m_features.EnhancedBarriers)
+        return false;
+    if (Requires.FeatureRequires.ArrBindless && !m_features.ArrBindless)
+        return false;
+    if (Requires.FeatureRequires.DynBindless && !m_features.DynBindless)
+        return false;
+    return true;
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Adapter.h b/Coplt.Graphics.Native/D3d12/Src/Adapter.h
new file mode 100644
index 0000000..9f4f58b
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/Adapter.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <wrl/client.h>
+
+#include "Device.h"
+#include "../../Api/Include/Object.h"
+#include "../FFI/Adapter.h"
+
+namespace Coplt
+{
+    struct D3d12GpuAdapter final : Object<D3d12GpuAdapter, FD3d12GpuAdapter>
+    {
+        Rc<D3d12Instance> m_instance{};
+        ComPtr<IDXGIAdapter1> m_adapter{};
+        std::wstring m_name_string{};
+        std::wstring m_driver_string{};
+
+        explicit D3d12GpuAdapter(Rc<D3d12Instance>&& instance, ComPtr<IDXGIAdapter1>&& adapter);
+
+        FResult CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept override;
+
+        b8 IsSupport(const FDeviceRequires& Requires) noexcept override;
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Binding.cc b/Coplt.Graphics.Native/D3d12/Src/Binding.cc
new file mode 100644
index 0000000..8fe6524
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/Binding.cc
@@ -0,0 +1,64 @@
+#include "Binding.h"
+
+#include "Layout.h"
+#include "../../Api/Include/Error.h"
+#include "../FFI/Layout.h"
+
+using namespace Coplt;
+
+D3d12ShaderBinding::D3d12ShaderBinding(
+    Rc<D3d12GpuDevice>&& device, const FShaderBindingCreateOptions& options
+) : m_device(std::move(device))
+{
+    m_dx_device = m_device->m_device;
+
+    m_layout = Rc<ID3d12ShaderLayout>::UnsafeClone(options.Layout->QueryInterface<ID3d12ShaderLayout>());
+    if (m_layout == nullptr)
+        COPLT_THROW("Layout from different backends");
+
+    const auto item_metas = m_layout->GetItemMetas();
+    m_f_views = std::vector<FView>(item_metas.size(), {});
+    m_views = std::vector<View>(item_metas.size(), {});
+}
+
+FResult D3d12ShaderBinding::SetName(const FStr8or16& name) noexcept
+{
+    return FResult::None();
+}
+
+FView* D3d12ShaderBinding::GetViews(u32* out_size) noexcept
+{
+    *out_size = m_f_views.size();
+    return m_f_views.data();
+}
+
+FResult D3d12ShaderBinding::Set(const u32 count, const FShaderBindingBatchSet* bindings) noexcept
+{
+    return feb([&]
+    {
+        Set(std::span(bindings, count));
+    });
+}
+
+void D3d12ShaderBinding::Set(const std::span<const FShaderBindingBatchSet> bindings)
+{
+    auto item_metas = m_layout->GetItemMetas();
+    auto item_defines = m_layout->GetItemDefines();
+    for (const auto& [View, Index] : bindings)
+    {
+        if (Index >= m_views.size())
+            COPLT_THROW("Index out of bounds");
+        const auto& define = item_defines[Index];
+        switch (View.Type)
+        {
+        case FViewType::None:
+            break;
+        case FViewType::Buffer:
+            if (!define.IsAllowBuffer())
+                COPLT_THROW_FMT("Binding index {} is not allowed to bind to buffer.", Index);
+            break;
+        }
+        m_f_views[Index] = View;
+        m_views[Index] = View;
+    }
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Binding.h b/Coplt.Graphics.Native/D3d12/Src/Binding.h
new file mode 100644
index 0000000..4e1f625
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/Binding.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "Device.h"
+#include "Layout.h"
+#include "../../Api/Include/Object.h"
+#include "../FFI/Binding.h"
+#include "../FFI/Layout.h"
+#include "../Include/View.h"
+
+namespace Coplt
+{
+    struct D3d12ShaderBinding final : Object<D3d12ShaderBinding, FD3d12ShaderBinding>
+    {
+        Rc<D3d12GpuDevice> m_device{};
+        ComPtr<ID3D12Device2> m_dx_device{};
+        Rc<ID3d12ShaderLayout> m_layout{};
+        std::vector<FView> m_f_views{};
+        std::vector<View> m_views{};
+        std::vector<u32> m_changed{};
+
+        explicit D3d12ShaderBinding(Rc<D3d12GpuDevice>&& device, const FShaderBindingCreateOptions& options);
+
+        FResult SetName(const FStr8or16& name) noexcept override;
+
+        FView* GetViews(u32* out_size) noexcept override;
+
+        FResult Set(u32 count, const FShaderBindingBatchSet* bindings) noexcept override;
+
+        void Set(std::span<const FShaderBindingBatchSet> bindings);
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Buffer.cc b/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
index e621e0b..fffc42f 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
@@ -7,50 +7,34 @@ D3d12GpuBuffer::D3d12GpuBuffer(Rc<D3d12GpuDevice>&& device, const FGpuBufferCrea
 {
     m_allocator = m_device->m_gpu_allocator;
 
-    m_state = FResourceState::Common;
+    m_state = FResState::BufferCommon();
     m_purpose = options.Purpose;
     m_cpu_access = options.CpuAccess;
-    m_life_time = options.LifeTime;
     m_size = options.Size;
     m_count = options.Count;
     m_stride = options.Stride;
     m_usage = options.Usage;
 
     if (HasAnyFlags(m_purpose, FResourcePurpose::DepthStencil | FResourcePurpose::ShadingRate))
-        throw WRuntimeException(L"Buffer does not support this purpose combination.");
-
-    m_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-    m_desc.Alignment = 0;
-    m_desc.Width = options.Size;
-    m_desc.Height = 1;
-    m_desc.DepthOrArraySize = 1;
-    m_desc.MipLevels = 1;
-    m_desc.Format = DXGI_FORMAT_UNKNOWN;
-    m_desc.SampleDesc.Count = 1;
-    m_desc.SampleDesc.Quality = 0;
-    m_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-    m_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
+        COPLT_THROW("Buffer does not support this purpose combination.");
+
+    m_desc = CD3DX12_RESOURCE_DESC1::Buffer(options.Size, D3D12_RESOURCE_FLAG_NONE);
     if (HasAnyFlags(m_purpose, FResourcePurpose::UnorderedAccess))
         m_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 
-    // 瞬态资源不会立即创建
-    if (m_life_time != FLifeTime::Transient)
-    {
-        m_resource = box<ResourcePack>(m_allocator.Get(), m_cpu_access, m_state, &m_desc, nullptr);
+    m_resource = box<ResourcePack>(m_device.get(), m_allocator.Get(), m_cpu_access, m_state, &m_desc, nullptr);
 
-        if (m_device->Debug())
-        {
-            chr | m_resource->m_resource >> SetNameEx(options.Name);
-        }
+    if (m_device->Debug())
+    {
+        chr | m_resource->m_resource >> SetNameEx(options.Name);
     }
 }
 
-FResult D3d12GpuBuffer::SetName(const Str8or16& name) noexcept
+FResult D3d12GpuBuffer::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
         if (!m_device->Debug()) return;
-        if (m_life_time == FLifeTime::Transient) return;
         chr | m_resource->m_resource >> SetNameEx(name);
     });
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Buffer.h b/Coplt.Graphics.Native/D3d12/Src/Buffer.h
index 4ba6e3c..023e6e4 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Buffer.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Buffer.h
@@ -1,4 +1,8 @@
 #pragma once
+
+#include <directx/d3d12.h>
+#include <directx/d3dx12.h>
+
 #include "../../Api/Include/Object.h"
 #include "../FFI/Resource.h"
 #include "Device.h"
@@ -12,11 +16,11 @@ namespace Coplt
         Rc<FString> m_name{};
         ComPtr<D3D12MA::Allocator> m_allocator{};
         Box<ResourcePack> m_resource{};
-        D3D12_RESOURCE_DESC m_desc{};
+        CD3DX12_RESOURCE_DESC1 m_desc{};
 
         explicit D3d12GpuBuffer(Rc<D3d12GpuDevice>&& device, const FGpuBufferCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         FResult GetCurrentResourcePtr(void* out) const noexcept override;
     };
diff --git a/Coplt.Graphics.Native/D3d12/Src/Command.cc b/Coplt.Graphics.Native/D3d12/Src/Command.cc
index 9a44db8..d15126d 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Command.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Command.cc
@@ -2,6 +2,7 @@
 #include "../../Api/FFI/Command.h"
 
 #include "Context.h"
+#include "DescriptorManager.h"
 #include "fmt/format.h"
 #include "fmt/xchar.h"
 
@@ -14,514 +15,496 @@
 #include "../Include/PipelineState.h"
 #include "../ThirdParty/DirectXTK12/Src/d3dx12.h"
 
+#include "pix3.h"
+
 using namespace Coplt;
 
-void D3d12CommandInterpreter::Context::ResetPipeline()
+void D3d12CommandInterpreter::BarrierContext::Reset()
 {
-    Pipeline = nullptr;
-    D3dPipeline = nullptr;
+    m_groups_count = 0;
+    m_global_barriers.clear();
+    m_texture_barriers.clear();
+    m_buffer_barriers.clear();
 }
 
-void D3d12CommandInterpreter::Context::Reset()
+void D3d12CommandInterpreter::BarrierContext::Add(const D3D12_GLOBAL_BARRIER& barrier)
 {
-    ResetPipeline();
-    NumRtv = 0;
-    Dsv = {COPLT_U32_MAX};
-    Ibv = {COPLT_U32_MAX};
-    NumVbv = 0;
+    m_global_barriers.push_back(barrier);
 }
 
-D3d12CommandInterpreter::D3d12CommandInterpreter(D3d12GpuQueue* queue) : m_queue(queue)
+void D3d12CommandInterpreter::BarrierContext::Add(const D3D12_TEXTURE_BARRIER& barrier)
 {
+    m_texture_barriers.push_back(barrier);
 }
 
-void D3d12CommandInterpreter::Interpret(const FCommandSubmit& submit)
+void D3d12CommandInterpreter::BarrierContext::Add(const D3D12_BUFFER_BARRIER& barrier)
 {
-    Init();
-    InitStates(submit);
-    CollectBarrier(submit);
-    Translate(submit);
-    Reset();
-}
-
-void D3d12CommandInterpreter::CmdNext()
-{
-    m_items.back().CommandCount++;
+    m_buffer_barriers.push_back(barrier);
 }
 
-void D3d12CommandInterpreter::ReqState(const FResourceRef ResSrc, const FResourceState ReqState)
+namespace
 {
-    auto& state = m_states[ResSrc.ResourceIndex];
-    const auto old_state = state.CurrentState;
-    const auto new_state = ChangeState(old_state, ToDx(ReqState));
-    const auto last_item_size = state.CurrentItemsSize;
-    if (new_state == old_state)
-    {
-        state.CurrentItemsSize = m_items.size();
-        return;
-    }
-    state.CurrentState = new_state;
-    if (!state.HasBarrier()) AddBarrier(state, ResSrc);
-    else if (!IsCompatible(old_state, new_state))
+    template <D3D12_BARRIER_TYPE Type, class T>
+    constexpr void AddBarrierGroup(
+        D3D12_BARRIER_GROUP (&barrier_groups)[3],
+        i32& groups_count, std::vector<T>& barriers
+    )
     {
-        if (last_item_size >= m_items.size()) BarNext();
-        state.LastState = old_state;
-        AddBarrier(state, ResSrc);
-    }
-    else
-    {
-        state.CurrentItemsSize = m_items.size();
-        m_barriers[state.CurrentBarrierIndex].Transition.StateAfter = state.CurrentState;
+        const auto index = groups_count;
+        groups_count++;
+        D3D12_BARRIER_GROUP group{};
+        group.Type = Type;
+        group.NumBarriers = barriers.size();
+        if constexpr (Type == D3D12_BARRIER_TYPE_GLOBAL)
+        {
+            group.pGlobalBarriers = barriers.data();
+        }
+        else if constexpr (Type == D3D12_BARRIER_TYPE_TEXTURE)
+        {
+            group.pTextureBarriers = barriers.data();
+        }
+        else if constexpr (Type == D3D12_BARRIER_TYPE_BUFFER)
+        {
+            group.pBufferBarriers = barriers.data();
+        }
+        else static_assert(false);
+        // ReSharper disable once CppSomeObjectMembersMightNotBeInitialized
+        barrier_groups[index] = group;
     }
 }
 
-void D3d12CommandInterpreter::MarkResUse(const FResourceRef ResSrc)
+void D3d12CommandInterpreter::BarrierContext::BuildBarriers()
 {
-    auto& state = m_states[ResSrc.ResourceIndex];
-    state.CurrentItemsSize = m_items.size();
+    if (!m_global_barriers.empty())
+        AddBarrierGroup<D3D12_BARRIER_TYPE_GLOBAL>(m_barrier_groups, m_groups_count, m_global_barriers);
+    if (!m_texture_barriers.empty())
+        AddBarrierGroup<D3D12_BARRIER_TYPE_TEXTURE>(m_barrier_groups, m_groups_count, m_texture_barriers);
+    if (!m_buffer_barriers.empty())
+        AddBarrierGroup<D3D12_BARRIER_TYPE_BUFFER>(m_barrier_groups, m_groups_count, m_buffer_barriers);
 }
 
-void D3d12CommandInterpreter::AddBarrier(ResState& state, const FResourceRef ResSrc)
+void D3d12CommandInterpreter::Context::Reset()
 {
-    state.CurrentItemsSize = m_items.size();
-    state.CurrentBarrierIndex = m_barriers.size();
-    D3D12_RESOURCE_BARRIER barrier{};
-    barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
-    barrier.Transition.pResource = state.Resource;
-    barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
-    barrier.Transition.StateBefore = state.LastState;
-    barrier.Transition.StateAfter = state.CurrentState;
-    m_barriers.push_back(barrier);
-    m_barrier_resources.push_back(ResSrc.ResourceIndex);
+    Pipeline = nullptr;
+    D3dPipeline = nullptr;
 }
 
-void D3d12CommandInterpreter::BarNext()
+D3d12CommandInterpreter::D3d12CommandInterpreter(D3d12GpuQueue* queue) : m_queue(queue)
 {
-    auto& item = m_items.back();
-    const auto size = m_barriers.size();
-    const auto count = size - m_last_barrier_index;
-    item.BarrierCount = count;
-    m_last_barrier_index = size;
-    m_items.push_back({.CommandIndex = item.CommandIndex + item.CommandCount, .BarrierIndex = m_last_barrier_index});
 }
 
-void D3d12CommandInterpreter::Init()
+void D3d12CommandInterpreter::Interpret(const FCommandSubmit& submit)
 {
-    m_items.push_back({});
+    Translate(submit);
+    Reset();
 }
 
 void D3d12CommandInterpreter::Reset()
 {
-    m_states.clear();
-    m_barriers.clear();
-    m_barrier_resources.clear();
-    m_items.clear();
-    m_last_barrier_index = 0;
+    m_barrier_context.Reset();
     m_context.Reset();
 }
 
-void D3d12CommandInterpreter::InitStates(const FCommandSubmit& submit)
-{
-    m_states.reserve(submit.ResourceCount);
-    for (u32 i = 0; i < submit.ResourceCount; ++i)
-    {
-        const auto& res = submit.Resources[i];
-        if (res.GetObjectPtr() == nullptr) throw WRuntimeException(fmt::format(L"Resource is null at {}", i));
-        ResState state{};
-        state.Resource = GetResource(res);
-        state.Type = res.Type;
-        state.CurrentState = state.LastState = ToDx(res.CurrentState);
-        m_states.push_back(state);
-    }
-}
-
-void D3d12CommandInterpreter::CollectBarrier(const FCommandSubmit& submit)
+void D3d12CommandInterpreter::Translate(const FCommandSubmit& submit)
 {
-    for (u32 i = 0; i < submit.CommandCount; ++i, CmdNext())
+    const auto& cmd_pack = m_queue->m_cmd;
+    const std::span command_items(submit.Commands, submit.CommandCount);
+    for (u32 i = 0; i < command_items.size(); i++)
     {
-        const auto& item = submit.Commands[i];
-
+        const auto& item = command_items[i];
         switch (item.Type)
         {
         case FCommandType::None:
-        case FCommandType::Transition:
-        case FCommandType::SetViewportScissor:
-            goto CmdNext;
         case FCommandType::Present:
-            goto Present;
+            continue;
+        case FCommandType::Label:
+            Label(submit, item.Label);
+            continue;
+        case FCommandType::BeginScope:
+            BeginScope(submit, item.BeginScope);
+            continue;
+        case FCommandType::EndScope:
+            EndScope(submit, item.EndScope);
+            continue;
+        case FCommandType::Barrier:
+            Barrier(submit, i, item.Barrier);
+            continue;
         case FCommandType::ClearColor:
-            goto ClearColor;
+            ClearColor(submit, i, item.ClearColor);
+            continue;
         case FCommandType::ClearDepthStencil:
-            goto ClearDepthStencil;
-        case FCommandType::SetRenderTargets:
-            goto SetRenderTargets;
+            ClearDepthStencil(submit, i, item.ClearDepthStencil);
+            continue;
+        case FCommandType::Bind:
+            continue; // todo
+        case FCommandType::BufferCopy:
+            BufferCopy(submit, i, item.BufferCopy);
+            continue;
+        case FCommandType::Render:
+            Render(submit, i, item.Render);
+            continue;
+        case FCommandType::Compute:
+            COPLT_THROW("TODO");
+
+        // subcommands
         case FCommandType::SetPipeline:
-            goto SetPipeline;
+        case FCommandType::SetBinding:
+        case FCommandType::SetViewportScissor:
         case FCommandType::SetMeshBuffers:
-            goto SetMeshBuffers;
         case FCommandType::Draw:
-            goto Draw;
         case FCommandType::Dispatch:
-            goto Dispatch;
-        case FCommandType::BufferCopy:
-            goto BufferCopy;
+            COPLT_THROW("Sub commands cannot be placed in the main command list");
         }
-        throw WRuntimeException(fmt::format(L"Unknown command type {}", static_cast<u32>(item.Type)));
+        COPLT_THROW_FMT("Unknown command type {}", static_cast<u32>(item.Type));
+    }
+}
+
+void D3d12CommandInterpreter::Label(const FCommandSubmit& submit, const FCommandLabel& cmd) const
+{
+    if (!m_queue->m_device->Debug()) return;
+    auto color = PIX_COLOR_DEFAULT;
+    if (cmd.HasColor) color = PIX_COLOR(cmd.Color[0], cmd.Color[1], cmd.Color[2]);
+    if (cmd.StrType == FStrType::Str8)
+    {
+        PIXSetMarker(m_queue->m_cmd.m_list0.Get(), color, "%s", reinterpret_cast<const char*>(submit.Str8 + cmd.StringIndex));
+    }
+    else
+    {
+        PIXSetMarker(m_queue->m_cmd.m_list0.Get(), color, L"%s", reinterpret_cast<const wchar_t*>(submit.Str16 + cmd.StringIndex));
+    }
+}
 
-    CmdNext:
+void D3d12CommandInterpreter::BeginScope(const FCommandSubmit& submit, const FCommandBeginScope& cmd) const
+{
+    if (!m_queue->m_device->Debug()) return;
+    auto color = PIX_COLOR_DEFAULT;
+    if (cmd.HasColor) color = PIX_COLOR(cmd.Color[0], cmd.Color[1], cmd.Color[2]);
+    if (cmd.StrType == FStrType::Str8)
+    {
+        PIXBeginEvent(m_queue->m_cmd.m_list0.Get(), color, "%s", reinterpret_cast<const char*>(submit.Str8 + cmd.StringIndex));
+    }
+    else
+    {
+        PIXBeginEvent(m_queue->m_cmd.m_list0.Get(), color, L"%s", reinterpret_cast<const wchar_t*>(submit.Str16 + cmd.StringIndex));
+    }
+}
+
+void D3d12CommandInterpreter::EndScope(const FCommandSubmit& submit, const FCommandEndScope& cmd) const
+{
+    if (!m_queue->m_device->Debug()) return;
+    PIXEndEvent(m_queue->m_cmd.m_list0.Get());
+}
+
+void D3d12CommandInterpreter::Barrier(const FCommandSubmit& submit, u32 i, const FCommandBarrier& cmd)
+{
+    m_barrier_context.Reset();
+    const std::span barriers = std::span(&submit.Barriers[cmd.BarrierIndex], cmd.BarrierCount);
+    for (const auto& barrier : barriers)
+    {
+        switch (barrier.Type)
         {
+        case FBarrierType::None:
             continue;
-        }
-    Present:
-        {
-            const auto& cmd = item.Present;
-            ReqState(cmd.Image, FResourceState::Present);
+        case FBarrierType::Global:
+            Barrier(submit, barrier.Global);
             continue;
-        }
-    ClearColor:
-        {
-            const auto& cmd = item.ClearColor;
-            ReqState(cmd.Image, FResourceState::RenderTarget);
+        case FBarrierType::Buffer:
+            Barrier(submit, barrier.Buffer);
             continue;
-        }
-    ClearDepthStencil:
-        {
-            const auto& cmd = item.ClearDepthStencil;
-            ReqState(cmd.Image, FResourceState::DepthWrite);
+        case FBarrierType::Image:
+            Barrier(submit, barrier.Image);
             continue;
+        default:
+            COPLT_THROW_FMT("Unknown barrier type {} at command {}", static_cast<u32>(barrier.Type), i);
         }
-    SetRenderTargets:
+    }
+    m_barrier_context.BuildBarriers();
+    if (m_barrier_context.m_groups_count == 0) return;
+    m_queue->m_cmd.m_list7->Barrier(m_barrier_context.m_groups_count, m_barrier_context.m_barrier_groups);
+}
+
+void D3d12CommandInterpreter::Barrier(const FCommandSubmit& submit, const FGlobalBarrier& item)
+{
+    D3D12_GLOBAL_BARRIER barrier{};
+    barrier.AccessBefore = ToDx(item.AccessBefore);
+    barrier.AccessAfter = ToDx(item.AccessAfter);
+    barrier.SyncBefore = CalcSync(item.StagesBefore, item.AccessBefore, item.AccessAfter);
+    barrier.SyncAfter = CalcSync(item.StagesAfter, item.AccessAfter, item.AccessBefore);
+    m_barrier_context.m_global_barriers.push_back(barrier);
+}
+
+void D3d12CommandInterpreter::Barrier(const FCommandSubmit& submit, const FBufferBarrier& item)
+{
+    D3D12_BUFFER_BARRIER barrier{};
+    barrier.pResource = GetResource(item.Buffer.Get(submit));
+    barrier.Offset = item.Offset;
+    barrier.Size = item.Size;
+    barrier.AccessBefore = ToDx(item.AccessBefore);
+    barrier.AccessAfter = ToDx(item.AccessAfter);
+    barrier.SyncBefore = CalcSync(item.StagesBefore, item.AccessBefore, item.AccessAfter);
+    barrier.SyncAfter = CalcSync(item.StagesAfter, item.AccessAfter, item.AccessBefore);
+    m_barrier_context.m_buffer_barriers.push_back(barrier);
+}
+
+void D3d12CommandInterpreter::Barrier(const FCommandSubmit& submit, const FImageBarrier& item)
+{
+    const auto cross_queue = HasFlags(item.Flags, FImageBarrierFlags::CrossQueue);
+    D3D12_TEXTURE_BARRIER barrier{};
+    barrier.pResource = GetResource(item.Image.Get(submit));
+    barrier.Subresources.IndexOrFirstMipLevel = item.SubResourceRange.IndexOrFirstMipLevel;
+    barrier.Subresources.NumMipLevels = item.SubResourceRange.NumMipLevels;
+    barrier.Subresources.FirstArraySlice = item.SubResourceRange.FirstArraySlice;
+    barrier.Subresources.NumArraySlices = item.SubResourceRange.NumArraySlices;
+    barrier.Subresources.FirstPlane = item.SubResourceRange.FirstPlane;
+    barrier.Subresources.NumPlanes = item.SubResourceRange.NumPlanes;
+    barrier.LayoutBefore = ToDx(item.LayoutBefore, cross_queue ? std::nullopt : std::optional(m_queue->m_queue_type));
+    barrier.LayoutAfter = ToDx(item.LayoutAfter, cross_queue ? std::nullopt : std::optional(m_queue->m_queue_type));
+    barrier.AccessBefore = ToDx(item.AccessBefore);
+    barrier.AccessAfter = ToDx(item.AccessAfter);
+    barrier.SyncBefore = CalcSync(item.StagesBefore, item.AccessBefore, item.AccessAfter);
+    barrier.SyncAfter = CalcSync(item.StagesAfter, item.AccessAfter, item.AccessBefore);
+    if (HasFlags(item.Flags, FImageBarrierFlags::Discard)) barrier.Flags |= D3D12_TEXTURE_BARRIER_FLAG_DISCARD;
+    m_barrier_context.m_texture_barriers.push_back(barrier);
+}
+
+void D3d12CommandInterpreter::ClearColor(const FCommandSubmit& submit, u32 i, const FCommandClearColor& cmd) const
+{
+    const auto rtv = GetRtv(cmd.Image.Get(submit));
+    m_queue->m_cmd->ClearRenderTargetView(
+        rtv, cmd.Color, cmd.RectCount,
+        cmd.RectCount == 0 ? nullptr : reinterpret_cast<const D3D12_RECT*>(&submit.Rects[cmd.RectIndex])
+    );
+}
+
+void D3d12CommandInterpreter::ClearDepthStencil(const FCommandSubmit& submit, u32 i, const FCommandClearDepthStencil& cmd) const
+{
+    D3D12_CPU_DESCRIPTOR_HANDLE dsv{}; // todo
+    D3D12_CLEAR_FLAGS flags{};
+    if (HasFlags(cmd.Clear, FDepthStencilClearFlags::Depth)) flags |= D3D12_CLEAR_FLAG_DEPTH;
+    if (HasFlags(cmd.Clear, FDepthStencilClearFlags::Stencil)) flags |= D3D12_CLEAR_FLAG_STENCIL;
+    m_queue->m_cmd->ClearDepthStencilView(
+        dsv, flags, cmd.Depth, cmd.Stencil, cmd.RectCount,
+        cmd.RectCount == 0 ? nullptr : reinterpret_cast<const D3D12_RECT*>(&submit.Rects[cmd.RectIndex])
+    );
+}
+
+void D3d12CommandInterpreter::BufferCopy(const FCommandSubmit& submit, u32 i, const FCommandBufferCopy& cmd) const
+{
+    const auto& cmd_pack = m_queue->m_cmd;
+    const auto& range = submit.BufferCopyRanges[cmd.RangeIndex];
+    if (cmd.SrcType == FBufferRefType::Buffer && cmd.DstType == FBufferRefType::Buffer)
+    {
+        const auto dst = GetResource(cmd.Dst.Buffer.Get(submit));
+        const auto src = GetResource(cmd.Src.Buffer.Get(submit));
+        if (range.Size == std::numeric_limits<u64>::max())
         {
-            const auto& cmd = item.SetRenderTargets;
-            if (!cmd.Dsv.IsEmpty())
-            {
-                ReqState(cmd.Dsv, FResourceState::DepthWrite);
-                m_context.Dsv = cmd.Dsv;
-            }
-            m_context.NumRtv = std::min(cmd.NumRtv, 8u);
-            for (u32 n = 0; n < m_context.NumRtv; ++n)
-            {
-                ReqState(cmd.Rtv[n], FResourceState::RenderTarget);
-                m_context.Rtv[n] = cmd.Rtv[n];
-            }
-            continue;
+            cmd_pack->CopyResource(dst, src);
         }
-    SetPipeline:
+        else
         {
-            const auto& cmd = item.SetPipeline;
-            SetPipelineContext(cmd.Pipeline, i);
+            cmd_pack->CopyBufferRegion(dst, range.DstOffset, src, range.SrcOffset, range.Size);
         }
-    SetMeshBuffers:
+    }
+    else if (cmd.SrcType == FBufferRefType::Upload && cmd.DstType == FBufferRefType::Buffer)
+    {
+        const auto dst = GetResource(cmd.Dst.Buffer.Get(submit));
+        if (cmd.Src.Upload.Index >= m_queue->m_frame_context->m_upload_buffers.size())
+            COPLT_THROW_FMT("Index out of bounds at command {}", i);
+        const auto& src_obj = m_queue->m_frame_context->m_upload_buffers[cmd.Src.Upload.Index];
+        if (range.SrcOffset + range.Size >= src_obj.m_size)
+            COPLT_THROW_FMT("Size out of range at command {}", i);
+        const auto src = src_obj.m_resource.m_resource.Get();
+        cmd_pack->CopyBufferRegion(dst, range.DstOffset, src, range.SrcOffset, range.Size);
+    }
+    else
+    {
+        COPLT_THROW_FMT(
+            "Unsupported copy combination {{ SrcType = {} DstType = {} }} at command {}",
+            static_cast<u8>(cmd.SrcType), static_cast<u8>(cmd.DstType), i
+        );
+    }
+}
+
+void D3d12CommandInterpreter::Render(const FCommandSubmit& submit, u32 i, const FCommandRender& cmd)
+{
+    m_context.Reset();
+    const auto& info = submit.RenderInfos[cmd.InfoIndex];
+    {
+        auto num_rtv = std::min(info.NumRtv, 8u);
+        D3D12_RENDER_PASS_RENDER_TARGET_DESC rts[num_rtv];
+        D3D12_RENDER_PASS_DEPTH_STENCIL_DESC ds[info.Dsv.IsEmpty() ? 0 : 1];
+        if (!info.Dsv.IsEmpty())
         {
-            const auto& cmd = item.SetMeshBuffers;
-            if (!cmd.IndexBuffer.Buffer.IsEmpty())
-            {
-                ReqState(cmd.IndexBuffer.Buffer, FResourceState::IndexBuffer);
-                m_context.Ibv = cmd.IndexBuffer.Buffer;
-            }
-            const auto vbs = reinterpret_cast<const FVertexBufferRange*>(&submit.Payload[cmd.VertexBuffersIndex]);
-            if (cmd.VertexStartSlot + cmd.VertexBufferCount >= 31)
-                throw WRuntimeException(fmt::format(
-                    L"The number of input buffers is out of range, the maximum allowed input slots is 31; at command {}",
-                    i
-                ));
-            for (u32 n = 0; n < cmd.VertexBufferCount; ++n)
+            const auto& d_load = info.DsvLoadOp[0];
+            const auto& d_store = info.DsvStoreOp[0];
+            const auto& s_load = info.DsvLoadOp[1];
+            const auto& s_store = info.DsvStoreOp[1];
+            D3D12_RENDER_PASS_DEPTH_STENCIL_DESC desc{};
+            desc.cpuDescriptor = GetDsv(info.Dsv.Get(submit));
+            desc.DepthBeginningAccess = ToDx(d_load, [&](D3D12_CLEAR_VALUE& cv)
             {
-                const auto& vb = vbs[n];
-                ReqState(vb.Buffer, FResourceState::VertexBuffer);
-                m_context.Vbv[cmd.VertexStartSlot + n] = vb.Buffer;
-            }
-            continue;
-        }
-    Graphics_MarkResUse:
-        {
-            const auto g_state = m_context.GPipeline->GetGraphicsState();
-            if (g_state->DsvFormat != FGraphicsFormat::Unknown && !m_context.Dsv.IsEmpty())
+                cv.Format = ToDx(info.DsvFormat);
+                cv.DepthStencil.Depth = info.Depth;
+            });
+            desc.DepthBeginningAccess = ToDx(s_load, [&](D3D12_CLEAR_VALUE& cv)
             {
-                MarkResUse(m_context.Dsv);
-            }
-            const auto num_rts = std::min(m_context.NumRtv, static_cast<u32>(g_state->NumRts));
-            for (u32 n = 0; n < num_rts; ++n)
+                cv.Format = ToDx(info.DsvFormat);
+                cv.DepthStencil.Stencil = info.Stencil;
+            });
+            desc.DepthEndingAccess = ToDx(d_store, [&](D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS& res)
             {
-                const auto rt = m_context.Rtv[n];
-                if (!rt.IsEmpty()) MarkResUse(rt);
-            }
-            if (const auto mesh_layout = m_context.GPipeline->GetMeshLayout())
+                const auto& res_info = submit.ResolveInfos[info.DsvResolveInfoIndex];
+                res.Format = ToDx(res_info.Format);
+                res.pSrcResource = GetResource(res_info.Src.Get(submit));
+                res.pDstResource = GetResource(res_info.Dst.Get(submit));
+                res.SubresourceCount = 0;
+                res.ResolveMode = ToDx(res_info.Mode);
+            });
+            desc.StencilEndingAccess = ToDx(s_store, [&](D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS& res)
             {
-                auto buffers = mesh_layout->GetBuffers();
-                for (u32 n = 0; n < buffers.size(); ++n)
-                {
-                    const auto vb = m_context.Vbv[n];
-                    if (!vb.IsEmpty()) MarkResUse(vb);
-                }
-            }
-            continue;
+                const auto& res_info = submit.ResolveInfos[info.DsvResolveInfoIndex];
+                res.Format = ToDx(res_info.Format);
+                res.pSrcResource = GetResource(res_info.Src.Get(submit));
+                res.pDstResource = GetResource(res_info.Dst.Get(submit));
+                res.SubresourceCount = 0;
+                res.ResolveMode = ToDx(res_info.Mode);
+            });
+            ds[0] = desc;
         }
-    Draw:
+        for (u32 n = 0; n < num_rtv; ++n)
         {
-            const auto& cmd = item.Draw;
-            if (cmd.Pipeline != nullptr) SetPipelineContext(cmd.Pipeline, i);
-            if (m_context.Pipeline == nullptr)
-                throw WRuntimeException(fmt::format(L"Pipeline not set at command {}", i));
-            goto Graphics_MarkResUse;
+            const auto& rtv = info.Rtv[n];
+            const auto& load = info.RtvLoadOp[n];
+            const auto& store = info.RtvStoreOp[n];
+            D3D12_RENDER_PASS_RENDER_TARGET_DESC desc{};
+            desc.cpuDescriptor = GetRtv(rtv.Get(submit));
+            desc.BeginningAccess = ToDx(load, [&](D3D12_CLEAR_VALUE& cv)
+            {
+                cv.Format = ToDx(info.RtvFormat[n]);
+                cv.Color[0] = info.Color[0];
+                cv.Color[1] = info.Color[1];
+                cv.Color[2] = info.Color[2];
+                cv.Color[3] = info.Color[3];
+            });
+            desc.EndingAccess = ToDx(store, [&](D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS& res)
+            {
+                const auto& res_info = submit.ResolveInfos[info.ResolveInfoIndex[n]];
+                res.Format = ToDx(res_info.Format);
+                res.pSrcResource = GetResource(res_info.Src.Get(submit));
+                res.pDstResource = GetResource(res_info.Dst.Get(submit));
+                res.SubresourceCount = 0;
+                res.ResolveMode = ToDx(res_info.Mode);
+            });
+            rts[n] = desc;
         }
-    Dispatch:
+        D3D12_RENDER_PASS_FLAGS flags = D3D12_RENDER_PASS_FLAG_NONE;
+        if (info.HasUavWrites) flags |= D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES;
+        m_queue->m_cmd.m_list4->BeginRenderPass(info.NumRtv, rts, info.Dsv.IsEmpty() ? nullptr : ds, flags);
+    }
+    const auto commands = std::span(submit.RenderCommands + cmd.CommandStartIndex, cmd.CommandCount);
+    for (u32 j = 0; j < commands.size(); j++)
+    {
+        const auto& item = commands[j];
+        switch (item.Type)
         {
-            const auto& cmd = item.Dispatch;
-            if (cmd.Pipeline != nullptr) SetPipelineContext(cmd.Pipeline, i);
-            if (m_context.Pipeline == nullptr)
-                throw WRuntimeException(fmt::format(L"Pipeline not set at command {}", i));
-            if (cmd.Type == FDispatchType::Mesh && m_context.GPipeline) goto Graphics_MarkResUse;
+        case FCommandType::None:
             continue;
-        }
-    BufferCopy:
-        {
-            const auto& cmd = item.BufferCopy;
-            switch (cmd.SrcType)
-            {
-            case FBufferRefType::Buffer:
-                ReqState(cmd.Src.Buffer, FResourceState::CopySrc);
-                break;
-            case FBufferRefType::Upload:
-                // 上传缓冲区状态永远在 GenericRead 不需要屏障
-                break;
-            }
-            switch (cmd.DstType)
-            {
-            case FBufferRefType::Buffer:
-                ReqState(cmd.Dst.Buffer, FResourceState::CopyDst);
-                break;
-            case FBufferRefType::Upload:
-                throw WRuntimeException(
-                    fmt::format(L"The upload buffer cannot be used as a copy target at command {}", i)
-                );
-            }
+        case FCommandType::Label:
+            Label(submit, item.Label);
+            continue;
+        case FCommandType::BeginScope:
+            BeginScope(submit, item.BeginScope);
+            continue;
+        case FCommandType::EndScope:
+            EndScope(submit, item.EndScope);
             continue;
+        case FCommandType::SetPipeline:
+            SetPipeline(m_queue->m_cmd, item.SetPipeline.Pipeline, j);
+            continue;
+        case FCommandType::SetBinding:
+            continue; // todo
+        case FCommandType::SetViewportScissor:
+            RenderSetViewportScissor(submit, j, item.SetViewportScissor);
+            continue;
+        case FCommandType::SetMeshBuffers:
+            RenderSetMeshBuffers(submit, j, item.SetMeshBuffers);
+            continue;
+        case FCommandType::Draw:
+            RenderDraw(submit, j, item.Draw);
+            continue;
+        case FCommandType::Dispatch:
+            RenderDispatch(submit, j, item.Dispatch);
+            continue;
+        case FCommandType::Present:
+        case FCommandType::Barrier:
+        case FCommandType::ClearColor:
+        case FCommandType::ClearDepthStencil:
+        case FCommandType::Bind:
+        case FCommandType::BufferCopy:
+        case FCommandType::Render:
+        case FCommandType::Compute:
+            COPLT_THROW("Main commands cannot be placed in the sub command list");
         }
+        COPLT_THROW_FMT("Unknown command type {}", static_cast<u32>(item.Type));
+    }
+    {
+        m_queue->m_cmd.m_list4->EndRenderPass();
     }
-    BarNext();
 }
 
-void D3d12CommandInterpreter::Translate(const FCommandSubmit& submit)
+void D3d12CommandInterpreter::RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd) const
 {
-    m_context.ResetPipeline();
-    const auto& cmd_pack = m_queue->m_cmd;
-    for (const auto& cmd_item : m_items)
+    if (cmd.Indexed)
     {
-        if (cmd_item.BarrierCount > 0)
-        {
-            cmd_pack->ResourceBarrier(cmd_item.BarrierCount, m_barriers.data() + cmd_item.BarrierIndex);
-        }
+        m_queue->m_cmd->DrawIndexedInstanced(cmd.VertexOrIndexCount, cmd.InstanceCount, cmd.FirstVertexOrIndex, cmd.VertexOffset, cmd.FirstInstance);
+    }
+    else
+    {
+        m_queue->m_cmd->DrawInstanced(cmd.VertexOrIndexCount, cmd.InstanceCount, cmd.FirstVertexOrIndex, cmd.FirstInstance);
+    }
+}
 
-        for (u32 i = 0; i < cmd_item.CommandCount; ++i)
-        {
-            const auto& item = submit.Commands[cmd_item.CommandIndex + i];
+void D3d12CommandInterpreter::RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd) const
+{
+    if (cmd.Type != FDispatchType::Mesh)
+        COPLT_THROW_FMT("Render only supports DispatchMesh and does not support Dispatch for Compute at command {}", i);
+    m_queue->m_cmd.m_list6->DispatchMesh(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
+}
 
-            switch (item.Type)
-            {
-            case FCommandType::None:
-            case FCommandType::Present:
-                continue;
-            case FCommandType::Transition:
-                goto Transition;
-            case FCommandType::ClearColor:
-                goto ClearColor;
-            case FCommandType::ClearDepthStencil:
-                goto ClearDepthStencil;
-            case FCommandType::SetRenderTargets:
-                goto SetRenderTargets;
-            case FCommandType::SetViewportScissor:
-                goto SetViewportScissor;
-            case FCommandType::SetPipeline:
-                goto SetPipeline;
-            case FCommandType::SetMeshBuffers:
-                goto SetMeshBuffers;
-            case FCommandType::Draw:
-                goto Draw;
-            case FCommandType::Dispatch:
-                goto Dispatch;
-            case FCommandType::BufferCopy:
-                goto BufferCopy;
-            }
-            throw WRuntimeException(fmt::format(L"Unknown command type {}", static_cast<u32>(item.Type)));
-
-        Transition:
-            throw WRuntimeException(L"TODO");
-            continue;
-        ClearColor:
-            {
-                const auto& cmd = item.ClearColor;
-                const auto rtv = GetRtv(cmd.Image.Get(submit));
-                cmd_pack->ClearRenderTargetView(
-                    rtv, cmd.Color, cmd.RectCount,
-                    cmd.RectCount == 0 ? nullptr : reinterpret_cast<const D3D12_RECT*>(&submit.Payload[cmd.RectIndex])
-                );
-                continue;
-            }
-        ClearDepthStencil:
-            {
-                const auto& cmd = item.ClearDepthStencil;
-                D3D12_CPU_DESCRIPTOR_HANDLE dsv{}; // todo
-                D3D12_CLEAR_FLAGS flags{};
-                if (HasFlags(cmd.Clear, FDepthStencilClearFlags::Depth)) flags |= D3D12_CLEAR_FLAG_DEPTH;
-                if (HasFlags(cmd.Clear, FDepthStencilClearFlags::Stencil)) flags |= D3D12_CLEAR_FLAG_STENCIL;
-                cmd_pack->ClearDepthStencilView(
-                    dsv, flags, cmd.Depth, cmd.Stencil, cmd.RectCount,
-                    cmd.RectCount == 0 ? nullptr : reinterpret_cast<const D3D12_RECT*>(&submit.Payload[cmd.RectIndex])
-                );
-                continue;
-            }
-        SetRenderTargets:
-            {
-                const auto& cmd = item.SetRenderTargets;
-                auto dsv = nullptr; // todo
-                auto num_rtv = std::min(cmd.NumRtv, 8u);
-                D3D12_CPU_DESCRIPTOR_HANDLE rtvs[num_rtv];
-                for (u32 n = 0; n < num_rtv; ++n)
-                {
-                    rtvs[n] = GetRtv(cmd.Rtv[n].Get(submit));
-                }
-                cmd_pack->OMSetRenderTargets(num_rtv, rtvs, false, dsv);
-
-                auto viewport = reinterpret_cast<const D3D12_VIEWPORT*>(&submit.Payload[cmd.ViewportIndex]);
-                auto scissor = reinterpret_cast<const D3D12_RECT*>(&submit.Payload[cmd.ScissorRectIndex]);
-                if (cmd.ViewportCount > 0) cmd_pack->RSSetViewports(cmd.ViewportCount, viewport);
-                if (cmd.ScissorRectCount > 0) cmd_pack->RSSetScissorRects(cmd.ScissorRectCount, scissor);
-                continue;
-            }
-        SetViewportScissor:
-            {
-                const auto& cmd = item.SetViewportScissor;
-                auto viewport = reinterpret_cast<const D3D12_VIEWPORT*>(&submit.Payload[cmd.ViewportIndex]);
-                auto scissor = reinterpret_cast<const D3D12_RECT*>(&submit.Payload[cmd.ScissorRectIndex]);
-                if (cmd.ViewportCount > 0) cmd_pack->RSSetViewports(cmd.ViewportCount, viewport);
-                if (cmd.ScissorRectCount > 0) cmd_pack->RSSetScissorRects(cmd.ScissorRectCount, scissor);
-                continue;
-            }
-        SetPipeline:
-            {
-                const auto& cmd = item.SetPipeline;
-                SetPipeline(cmd_pack, cmd.Pipeline, i);
-                continue;
-            }
-        SetMeshBuffers:
-            {
-                const auto& cmd = item.SetMeshBuffers;
-                const auto defs = cmd.MeshLayout->GetBuffers();
-                const auto vbs = reinterpret_cast<const FVertexBufferRange*>(&submit.Payload[cmd.VertexBuffersIndex]);
-                if (!cmd.IndexBuffer.Buffer.IsEmpty())
-                {
-                    const auto resource = GetResource(cmd.IndexBuffer.Buffer.Get(submit));
-                    D3D12_INDEX_BUFFER_VIEW view{};
-                    view.BufferLocation = resource->GetGPUVirtualAddress() + cmd.IndexBuffer.Offset;
-                    view.SizeInBytes = cmd.IndexBuffer.Size;
-                    view.Format = Coplt::ToDx(cmd.IndexFormat);
-                    cmd_pack->IASetIndexBuffer(&view);
-                }
-                {
-                    D3D12_VERTEX_BUFFER_VIEW views[cmd.VertexBufferCount];
-                    for (u32 n = 0; n < cmd.VertexBufferCount; ++n)
-                    {
-                        auto& range = vbs[n];
-                        const auto& def = defs[range.Index];
-                        const auto resource = GetResource(range.Buffer.Get(submit));
-                        D3D12_VERTEX_BUFFER_VIEW view{};
-                        view.BufferLocation = resource->GetGPUVirtualAddress() + range.Offset;
-                        view.SizeInBytes = range.Size;
-                        view.StrideInBytes = def.Stride;
-                        views[n] = view;
-                    }
-                    cmd_pack->IASetVertexBuffers(cmd.VertexStartSlot, cmd.VertexBufferCount, views);
-                }
-                continue;
-            }
-        Draw:
-            {
-                const auto& cmd = item.Draw;
-                if (cmd.Pipeline != nullptr) SetPipeline(cmd_pack, cmd.Pipeline, i);
-                if (m_context.Pipeline == nullptr)
-                    throw WRuntimeException(fmt::format(L"Pipeline not set at command {}", i));
-                const auto stages = m_context.Pipeline->GetStages();
-                if (!HasFlags(stages, FShaderStageFlags::Vertex))
-                    throw WRuntimeException(L"Non Vertex pipelines cannot use Draw");
-                if (cmd.Indexed)
-                {
-                    cmd_pack->DrawIndexedInstanced(
-                        cmd.VertexOrIndexCount, cmd.InstanceCount,
-                        cmd.FirstVertexOrIndex, cmd.VertexOffset, cmd.FirstInstance
-                    );
-                }
-                else
-                {
-                    cmd_pack->DrawInstanced(
-                        cmd.VertexOrIndexCount, cmd.InstanceCount,
-                        cmd.FirstVertexOrIndex, cmd.FirstInstance
-                    );
-                }
-                continue;
-            }
-        Dispatch:
-            {
-                const auto& cmd = item.Dispatch;
-                if (cmd.Pipeline != nullptr) SetPipeline(cmd_pack, cmd.Pipeline, i);
-                FShaderStageFlags stages{};
-                switch (cmd.Type)
-                {
-                case FDispatchType::Compute:
-                    cmd_pack->Dispatch(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
-                    break;
-                case FDispatchType::Mesh:
-                    if (!cmd_pack.m_list7)
-                        throw WRuntimeException(L"Mesh Shader is not supported on this device");
-                    cmd_pack.m_list7->DispatchMesh(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
-                    break;
-                default:
-                    throw WRuntimeException(
-                        fmt::format(L"Unknown dispatch type {} at command {}", static_cast<u32>(cmd.Type), i)
-                    );
-                }
-                continue;
-            }
-        BufferCopy:
-            {
-                const auto& cmd = item.BufferCopy;
-                if (cmd.SrcType == FBufferRefType::Buffer && cmd.DstType == FBufferRefType::Buffer)
-                {
-                    const auto dst = GetResource(cmd.Dst.Buffer.Get(submit));
-                    const auto src = GetResource(cmd.Src.Buffer.Get(submit));
-                    if (cmd.Size == std::numeric_limits<u64>::max())
-                    {
-                        cmd_pack->CopyResource(dst, src);
-                    }
-                    else
-                    {
-                        cmd_pack->CopyBufferRegion(dst, cmd.DstOffset, src, cmd.SrcOffset, cmd.Size);
-                    }
-                }
-                else if (cmd.SrcType == FBufferRefType::Upload && cmd.DstType == FBufferRefType::Buffer)
-                {
-                    const auto dst = GetResource(cmd.Dst.Buffer.Get(submit));
-                    if (cmd.Src.Upload.Index >= m_queue->m_frame_context->m_upload_buffers.size())
-                        throw WRuntimeException(fmt::format(L"Index out of bounds at command {}", i));
-                    const auto& src_obj = m_queue->m_frame_context->m_upload_buffers[cmd.Src.Upload.Index];
-                    if (cmd.SrcOffset + cmd.Size >= src_obj.m_size)
-                        throw WRuntimeException(fmt::format(L"Size out of range at command {}", i));
-                    const auto src = src_obj.m_resource.m_resource.Get();
-                    cmd_pack->CopyBufferRegion(dst, cmd.DstOffset, src, cmd.SrcOffset, cmd.Size);
-                }
-                else
-                {
-                    throw WRuntimeException(
-                        fmt::format(
-                            L"Unsupported copy combination {{ SrcType = {} DstType = {} }} at command {}",
-                            static_cast<u8>(cmd.SrcType), static_cast<u8>(cmd.DstType), i
-                        )
-                    );
-                }
-                continue;
-            }
-        }
+void D3d12CommandInterpreter::RenderSetViewportScissor(const FCommandSubmit& submit, u32 i, const FCommandSetViewportScissor& cmd) const
+{
+    m_queue->m_cmd->RSSetViewports(cmd.ViewportCount, reinterpret_cast<const D3D12_VIEWPORT*>(submit.Viewports + cmd.ViewportIndex));
+    m_queue->m_cmd->RSSetScissorRects(cmd.ScissorRectCount, reinterpret_cast<const D3D12_RECT*>(submit.Rects + cmd.ScissorRectIndex));
+}
+
+void D3d12CommandInterpreter::RenderSetMeshBuffers(const FCommandSubmit& submit, u32 i, const FCommandSetMeshBuffers& cmd) const
+{
+    const auto& cmd_pack = m_queue->m_cmd;
+    const auto& buffers = submit.MeshBuffers[cmd.PayloadIndex];
+    const auto defs = buffers.MeshLayout->GetBuffers();
+    const auto vbs = std::span(submit.VertexBufferRanges + buffers.VertexBuffersIndex, buffers.VertexBufferCount);
+    if (!buffers.IndexBuffer.Buffer.IsEmpty())
+    {
+        const auto resource = GetResource(buffers.IndexBuffer.Buffer.Get(submit));
+        D3D12_INDEX_BUFFER_VIEW view{};
+        view.BufferLocation = resource->GetGPUVirtualAddress() + buffers.IndexBuffer.Offset;
+        view.SizeInBytes = buffers.IndexBuffer.Size;
+        view.Format = ToDx(cmd.IndexFormat);
+        cmd_pack->IASetIndexBuffer(&view);
+    }
+    D3D12_VERTEX_BUFFER_VIEW views[vbs.size()];
+    for (u32 j = 0; j < vbs.size(); j++)
+    {
+        const auto& range = vbs[j];
+        const auto& def = defs[range.Index];
+        const auto resource = GetResource(range.Buffer.Get(submit));
+        D3D12_VERTEX_BUFFER_VIEW view{};
+        view.BufferLocation = resource->GetGPUVirtualAddress() + range.Offset;
+        view.SizeInBytes = range.Size;
+        view.StrideInBytes = def.Stride;
+        views[j] = view;
     }
+    cmd_pack->IASetVertexBuffers(cmd.VertexStartSlot, buffers.VertexBufferCount, views);
 }
 
 void D3d12CommandInterpreter::SetPipelineContext(FShaderPipeline* pipeline, const u32 i)
@@ -530,22 +513,22 @@ void D3d12CommandInterpreter::SetPipelineContext(FShaderPipeline* pipeline, cons
     m_context.Pipeline = pipeline;
     m_context.D3dPipeline = pipeline->QueryInterface<FD3d12PipelineState>();
     if (!m_context.D3dPipeline)
-        throw WRuntimeException(
-            fmt::format(
-                L"Pipeline({:#x}) comes from different backends at cmd {}",
-                reinterpret_cast<size_t>(pipeline), i
-            )
+    {
+        COPLT_THROW_FMT(
+            "Pipeline({:#x}) comes from different backends at cmd {}",
+            reinterpret_cast<size_t>(pipeline), i
         );
+    }
     m_context.Layout = pipeline->GetLayout()->QueryInterface<FD3d12ShaderLayout>();
     if (!m_context.Layout)
-        throw WRuntimeException(L"Shader layout from different backends");
+        COPLT_THROW("Shader layout from different backends");
     const auto stages = pipeline->GetStages();
     m_context.GPipeline = nullptr;
     if (HasFlags(stages, FShaderStageFlags::Pixel))
     {
         m_context.GPipeline = pipeline->QueryInterface<FD3d12GraphicsShaderPipeline>();
         if (!m_context.GPipeline)
-            throw WRuntimeException(L"Pipeline from different backends or pipeline not a graphics pipeline");
+            COPLT_THROW("Pipeline from different backends or pipeline not a graphics pipeline");
     }
 }
 
@@ -579,11 +562,12 @@ ID3D12Resource* D3d12CommandInterpreter::GetResource(FUnknown* object, FResource
     switch (type)
     {
     case FResourceRefType::Image:
-        throw WRuntimeException(L"TODO");
+        COPLT_THROW("TODO");
     case FResourceRefType::Buffer:
         {
             const auto buffer = object->QueryInterface<FD3d12GpuBuffer>();
-            if (!buffer) throw WRuntimeException(L"The memory may be corrupted");
+            if (!buffer)
+                COPLT_THROW("The memory may be corrupted");
             ID3D12Resource* ptr{};
             buffer->GetCurrentResourcePtr(&ptr).TryThrow();
             return ptr;
@@ -591,13 +575,14 @@ ID3D12Resource* D3d12CommandInterpreter::GetResource(FUnknown* object, FResource
     case FResourceRefType::Output:
         {
             const auto output = object->QueryInterface<FD3d12GpuOutput>();
-            if (!output) throw WRuntimeException(L"The memory may be corrupted");
+            if (!output)
+                COPLT_THROW("The memory may be corrupted");
             ID3D12Resource* ptr{};
             output->GetCurrentResourcePtr(&ptr).TryThrow();
             return ptr;
         }
     default:
-        throw WRuntimeException(fmt::format(L"Unknown resource ref type {}", static_cast<u8>(type)));
+        COPLT_THROW_FMT("Unknown resource ref type {}", static_cast<u8>(type));
     }
 }
 
@@ -607,16 +592,31 @@ D3D12_CPU_DESCRIPTOR_HANDLE D3d12CommandInterpreter::GetRtv(const FResourceMeta&
     {
     case FResourceRefType::Image:
     case FResourceRefType::Buffer:
-        throw WRuntimeException(L"TODO");
+        COPLT_THROW("TODO");
     case FResourceRefType::Output:
         {
             const auto output = meta.Output->QueryInterface<FD3d12GpuOutput>();
-            if (!output) throw WRuntimeException(L"The memory may be corrupted");
+            if (!output)
+                COPLT_THROW("The memory may be corrupted");
             D3D12_CPU_DESCRIPTOR_HANDLE rtv{};
             output->GetCurrentRtv(&rtv).TryThrow();
             return rtv;
         }
     default:
-        throw WRuntimeException(fmt::format(L"Unknown resource ref type {}", static_cast<u8>(meta.Type)));
+        COPLT_THROW_FMT("Unknown resource ref type {}", static_cast<u8>(meta.Type));
+    }
+}
+
+D3D12_CPU_DESCRIPTOR_HANDLE D3d12CommandInterpreter::GetDsv(const FResourceMeta& meta)
+{
+    switch (meta.Type)
+    {
+    case FResourceRefType::Image:
+    case FResourceRefType::Buffer:
+        COPLT_THROW("TODO");
+    case FResourceRefType::Output:
+        COPLT_THROW("Output does not support Dsv usage");
+    default:
+        COPLT_THROW_FMT("Unknown resource ref type {}", static_cast<u8>(meta.Type));
     }
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Command.h b/Coplt.Graphics.Native/D3d12/Src/Command.h
index 5116d6a..7993b5f 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Command.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Command.h
@@ -9,6 +9,7 @@
 #include "../Include/States.h"
 
 #include "CmdListPack.h"
+#include "../../Api/Include/ChunkedVector.h"
 
 namespace Coplt
 {
@@ -22,61 +23,40 @@ namespace Coplt
         D3d12GpuQueue* m_queue{};
 
     private:
-        struct ResState
+        struct BarrierContext
         {
-            ID3D12Resource* Resource{};
-            D3D12_RESOURCE_STATES LastState{};
-            D3D12_RESOURCE_STATES CurrentState{};
-            u32 CurrentBarrierIndex{COPLT_U32_MAX};
-            // 记录最后使用的项块
-            u32 CurrentItemsSize{COPLT_U32_MAX};
-            FResourceRefType Type{};
-
-            bool HasBarrier() const { return CurrentBarrierIndex != COPLT_U32_MAX; }
-        };
+            D3D12_BARRIER_GROUP m_barrier_groups[3]{};
+            i32 m_groups_count = 0;
+            std::vector<D3D12_GLOBAL_BARRIER> m_global_barriers{};
+            std::vector<D3D12_TEXTURE_BARRIER> m_texture_barriers{};
+            std::vector<D3D12_BUFFER_BARRIER> m_buffer_barriers{};
 
-        enum class ItemType
-        {
-            Command,
-            Barrier,
-        };
+            void Reset();
 
-        struct Item
-        {
-            u32 CommandIndex{};
-            u32 CommandCount{};
-            u32 BarrierIndex{};
-            u32 BarrierCount{};
+            void Add(const D3D12_GLOBAL_BARRIER& barrier);
+            void Add(const D3D12_TEXTURE_BARRIER& barrier);
+            void Add(const D3D12_BUFFER_BARRIER& barrier);
+
+            void BuildBarriers();
         };
 
         struct Context
         {
-            // 以下在屏障阶段和转译阶段都会使用
-
             FShaderPipeline* Pipeline{};
             FD3d12PipelineState* D3dPipeline{};
             FD3d12ShaderLayout* Layout{};
             // 如果不是图形管线将不会设置
             FD3d12GraphicsShaderPipeline* GPipeline{};
 
-            // 以下仅在屏障阶段使用
-
-            FResourceRef Rtv[8];
-            u32 NumRtv{};
-            FResourceRef Dsv{COPLT_U32_MAX};
-            FResourceRef Ibv{COPLT_U32_MAX};
-            FResourceRef Vbv[31];
-            u32 NumVbv{};
-
-            void ResetPipeline();
             void Reset();
         };
 
-        std::vector<ResState> m_states{};
-        std::vector<D3D12_RESOURCE_BARRIER> m_barriers{};
-        std::vector<u32> m_barrier_resources{};
-        std::vector<Item> m_items{};
-        u32 m_last_barrier_index{};
+        // std::vector<ResState> m_states{};
+        // std::vector<D3D12_RESOURCE_BARRIER> m_barriers{};
+        // std::vector<u32> m_barrier_resources{};
+        // std::vector<Item> m_items{};
+        // u32 m_last_barrier_index{};
+        BarrierContext m_barrier_context{};
         Context m_context{};
 
     public:
@@ -84,22 +64,27 @@ namespace Coplt
 
         void Interpret(const FCommandSubmit& submit);
 
-        void CmdNext();
-        void ReqState(FResourceRef ResSrc, FResourceState ReqState);
-        void MarkResUse(FResourceRef ResSrc);
-        void AddBarrier(ResState& state, FResourceRef ResSrc);
-        void BarNext();
-
     private:
-        void Init();
         void Reset();
 
-        void InitStates(const FCommandSubmit& submit);
-
-        void CollectBarrier(const FCommandSubmit& submit);
-
         void Translate(const FCommandSubmit& submit);
 
+        void Label(const FCommandSubmit& submit, const FCommandLabel& cmd) const;
+        void BeginScope(const FCommandSubmit& submit, const FCommandBeginScope& cmd) const;
+        void EndScope(const FCommandSubmit& submit, const FCommandEndScope& cmd) const;
+        void Barrier(const FCommandSubmit& submit, u32 i, const FCommandBarrier& cmd);
+        void Barrier(const FCommandSubmit& submit, const FGlobalBarrier& item);
+        void Barrier(const FCommandSubmit& submit, const FBufferBarrier& item);
+        void Barrier(const FCommandSubmit& submit, const FImageBarrier& item);
+        void ClearColor(const FCommandSubmit& submit, u32 i, const FCommandClearColor& cmd) const;
+        void ClearDepthStencil(const FCommandSubmit& submit, u32 i, const FCommandClearDepthStencil& cmd) const;
+        void BufferCopy(const FCommandSubmit& submit, u32 i, const FCommandBufferCopy& cmd) const;
+        void Render(const FCommandSubmit& submit, u32 i, const FCommandRender& cmd);
+        void RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd) const;
+        void RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd) const;
+        void RenderSetViewportScissor(const FCommandSubmit& submit, u32 i, const FCommandSetViewportScissor& cmd) const;
+        void RenderSetMeshBuffers(const FCommandSubmit& submit, u32 i, const FCommandSetMeshBuffers& cmd) const;
+
         void SetPipelineContext(
             FShaderPipeline* pipeline, u32 i
         );
@@ -108,9 +93,8 @@ namespace Coplt
         );
 
         static ID3D12Resource* GetResource(const FResourceMeta& meta);
-
         static ID3D12Resource* GetResource(FUnknown* object, FResourceRefType type);
-
         static D3D12_CPU_DESCRIPTOR_HANDLE GetRtv(const FResourceMeta& meta);
+        static D3D12_CPU_DESCRIPTOR_HANDLE GetDsv(const FResourceMeta& meta);
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Context.cc b/Coplt.Graphics.Native/D3d12/Src/Context.cc
index af3f589..7e0acf1 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Context.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Context.cc
@@ -18,7 +18,7 @@ D3d12FrameContext::D3d12FrameContext(Rc<D3d12GpuQueue>&& queue) : m_queue(std::m
     );
     if (m_device->Debug())
     {
-        chr | m_command_allocator >> SetNameEx(Str8or16(fmt::format(L"Frame Context ({}) Command Allocator", m_id)));
+        chr | m_command_allocator >> SetNameEx(FStr8or16(fmt::format(L"Frame Context ({}) Command Allocator", m_id)));
     }
 }
 
@@ -34,7 +34,7 @@ FResult D3d12FrameContext::GrowUploadBuffer(const u64 min_required_size) noexcep
         m_cur_upload_buffer_index = m_upload_buffers.size();
         m_cur_upload_buffer_size = size;
         m_upload_buffers.push_back(
-            BufferPack(m_device->m_gpu_allocator.Get(), FCpuAccess::Write, m_cur_upload_buffer_size)
+            BufferPack(m_device.get(), m_device->m_gpu_allocator.Get(), FCpuAccess::Write, m_cur_upload_buffer_size)
         );
         const auto& upload_buffer = m_upload_buffers.back();
         void* mapped_ptr{};
@@ -43,7 +43,7 @@ FResult D3d12FrameContext::GrowUploadBuffer(const u64 min_required_size) noexcep
             const auto name = fmt::format(
                 L"Frame Context ({}) Upload Buffer ({})", m_id, upload_buffer.m_size
             );
-            chr | upload_buffer.m_resource.m_resource >> SetNameEx(Str8or16(name));
+            chr | upload_buffer.m_resource.m_resource >> SetNameEx(FStr8or16(name));
         }
         constexpr D3D12_RANGE read_range{.Begin = 0, .End = 0};
         chr | upload_buffer.m_resource.m_resource->Map(0, &read_range, &mapped_ptr);
diff --git a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc
new file mode 100644
index 0000000..7d1ed40
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc
@@ -0,0 +1,35 @@
+#include "DescriptorManager.h"
+
+using namespace Coplt;
+
+CpuDescriptorSet::CpuDescriptorSet(
+    ComPtr<ID3D12Device2> device, const D3D12_DESCRIPTOR_HEAP_TYPE type, const u32 init_cap
+) : m_device(std::move(device)), m_type(type), m_cap(init_cap)
+{
+    D3D12_DESCRIPTOR_HEAP_DESC desc{};
+    desc.Type = type;
+    desc.NumDescriptors = init_cap;
+    chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_heap));
+}
+
+GpuDescriptorSet::GpuDescriptorSet(
+    ComPtr<ID3D12Device2> device, const D3D12_DESCRIPTOR_HEAP_TYPE type, const u32 init_cap
+) : m_device(std::move(device)), m_type(type), m_cap(init_cap)
+{
+    D3D12_DESCRIPTOR_HEAP_DESC desc{};
+    desc.Type = type;
+    desc.NumDescriptors = init_cap;
+    chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_Cpu_heap));
+    desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+    chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_Gpu_heap));
+}
+
+DescriptorManager::DescriptorManager(D3d12GpuDevice* device) : m_device(device)
+{
+    m_dx_device = m_device->m_device;
+
+    m_rtv_set = box<CpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, RtvDsvInitCap);
+    m_dsv_set = box<CpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, RtvDsvInitCap);
+    m_cbv_srv_uav_set = box<GpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, CbvSrvUavInitCap);
+    m_sampler_set = box<GpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, SamplerInitCap);
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h
new file mode 100644
index 0000000..0a59129
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <concurrent_queue.h>
+
+#include "Device.h"
+
+namespace Coplt
+{
+    struct CpuDescriptorSet
+    {
+        ComPtr<ID3D12Device2> m_device{};
+
+        D3D12_DESCRIPTOR_HEAP_TYPE m_type{};
+        ComPtr<ID3D12DescriptorHeap> m_heap{};
+
+        u32 m_used{};
+        u32 m_cap{};
+
+        explicit CpuDescriptorSet(ComPtr<ID3D12Device2> device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 init_cap);
+    };
+
+    struct GpuDescriptorSet
+    {
+        ComPtr<ID3D12Device2> m_device{};
+
+        D3D12_DESCRIPTOR_HEAP_TYPE m_type{};
+        ComPtr<ID3D12DescriptorHeap> m_Cpu_heap{};
+        ComPtr<ID3D12DescriptorHeap> m_Gpu_heap{};
+
+        u32 m_used{};
+        u32 m_cap{};
+
+        explicit GpuDescriptorSet(ComPtr<ID3D12Device2> device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 init_cap);
+    };
+
+    struct DescriptorManager final
+    {
+        constexpr static u32 RtvDsvInitCap = 128;
+        constexpr static u32 SamplerInitCap = 128;
+        constexpr static u32 CbvSrvUavInitCap = 1024;
+
+        D3d12GpuDevice* m_device;
+        ComPtr<ID3D12Device2> m_dx_device{};
+
+        Box<CpuDescriptorSet> m_rtv_set{};
+        Box<CpuDescriptorSet> m_dsv_set{};
+        Box<GpuDescriptorSet> m_cbv_srv_uav_set{};
+        Box<GpuDescriptorSet> m_sampler_set{};
+
+        explicit DescriptorManager(D3d12GpuDevice* device);
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Device.cc b/Coplt.Graphics.Native/D3d12/Src/Device.cc
index cb19cab..8e54792 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Device.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Device.cc
@@ -1,8 +1,10 @@
 #include "Device.h"
 
-#include "dxgi1_6.h"
+#include "Binding.h"
 
 #include "../../Api/Src/Shader.h"
+#include "Adapter.h"
+#include "DescriptorManager.h"
 #include "Buffer.h"
 #include "GraphicsPipeline.h"
 #include "Layout.h"
@@ -12,63 +14,6 @@ using namespace Coplt;
 
 namespace
 {
-    void GetAdapter(
-        IDXGIFactory4* factory, IDXGIAdapter1** out_adapter,
-        D3D_FEATURE_LEVEL feature_level, const FGpuDeviceCreateOptions& options
-    )
-    {
-        ComPtr<IDXGIFactory6> factory6{};
-        ComPtr<IDXGIAdapter1> adapter{};
-        if (SUCCEEDED(factory->QueryInterface(IID_PPV_ARGS(&factory6))))
-        {
-            const DXGI_GPU_PREFERENCE preference =
-                options.Preference == FGpuPreference::HighPerformance
-                    ? DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE
-                    : options.Preference == FGpuPreference::MinimumPower
-                    ? DXGI_GPU_PREFERENCE_MINIMUM_POWER
-                    : DXGI_GPU_PREFERENCE_UNSPECIFIED;
-            for (
-                UINT index = 0;
-                SUCCEEDED(factory6->EnumAdapterByGpuPreference(index, preference, IID_PPV_ARGS(&adapter)));
-                ++index)
-            {
-                DXGI_ADAPTER_DESC1 desc{};
-                adapter->GetDesc1(&desc);
-
-                if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
-                {
-                    continue;
-                }
-
-                if (SUCCEEDED(D3D12CreateDevice(adapter.Get(), feature_level, _uuidof(ID3D12Device), nullptr)))
-                {
-                    break;
-                }
-            }
-        }
-
-        if (adapter.Get() == nullptr)
-        {
-            for (UINT index = 0; SUCCEEDED(factory->EnumAdapters1(index, &adapter)); ++index)
-            {
-                DXGI_ADAPTER_DESC1 desc{};
-                adapter->GetDesc1(&desc);
-
-                if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
-                {
-                    continue;
-                }
-
-                if (SUCCEEDED(D3D12CreateDevice(adapter.Get(), feature_level, _uuidof(ID3D12Device), nullptr)))
-                {
-                    break;
-                }
-            }
-        }
-
-        *out_adapter = adapter.Detach();
-    }
-
     void debug_callback(
         D3D12_MESSAGE_CATEGORY Category,
         D3D12_MESSAGE_SEVERITY Severity,
@@ -97,62 +42,20 @@ namespace
     }
 }
 
-D3d12GpuDevice::D3d12GpuDevice(
-    Rc<D3d12Instance> instance,
-    const FGpuDeviceCreateOptions& options
-) : m_instance(std::move(instance))
+D3d12GpuDevice::D3d12GpuDevice(Rc<D3d12GpuAdapter>&& adapter, const FGpuDeviceCreateOptions& options):
+    m_adapter(std::move(adapter))
 {
-    UINT dxgi_flags = 0;
-
-    if (options.Debug)
-    {
-        if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&m_debug_controller))))
-        {
-            m_debug_controller->EnableDebugLayer();
-            dxgi_flags |= DXGI_CREATE_FACTORY_DEBUG;
-
-            if (options.GpuBasedValidation)
-            {
-                ComPtr<ID3D12Debug1> debug1{};
-                if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug1>(&debug1)))
-                {
-                    debug1->SetEnableGPUBasedValidation(true);
-                }
-                ComPtr<ID3D12Debug2> debug2{};
-                if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug2>(&debug2)))
-                {
-                    debug2->SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING);
-                }
-            }
-
-            ComPtr<ID3D12Debug5> debug5{};
-            if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug5>(&debug5)))
-            {
-                debug5->SetEnableAutoName(true);
-            }
-        }
-        else m_debug_controller = nullptr;
-    }
+    m_instance = m_adapter->m_instance;
 
-    chr | CreateDXGIFactory2(dxgi_flags, IID_PPV_ARGS(&m_factory));
-
-    const auto feature_level =
-        options.D3dFeatureLevel == FD3dFeatureLevel::Unset
-            ? D3D_FEATURE_LEVEL_12_2
-            : static_cast<D3D_FEATURE_LEVEL>(options.D3dFeatureLevel);
-
-    GetAdapter(m_factory.Get(), &m_adapter, feature_level, options);
-    if (!m_adapter)
-        throw WRuntimeException(L"No matching devices found");
-
-    chr | D3D12CreateDevice(m_adapter.Get(), feature_level, IID_PPV_ARGS(&m_device));
+    const auto feature_level = static_cast<D3D_FEATURE_LEVEL>(m_adapter->m_d3d_feature_level);
+    chr | D3D12CreateDevice(m_adapter->m_adapter.Get(), feature_level, IID_PPV_ARGS(&m_device));
 
     D3D12MA::ALLOCATOR_DESC allocator_desc{};
     D3D12MA::ALLOCATION_CALLBACKS allocation_callbacks{};
     allocation_callbacks.pAllocate = [](auto size, auto align, auto data) { return mi_malloc_aligned(size, align); };
     allocation_callbacks.pFree = [](auto ptr, auto data) { return mi_free(ptr); };
     allocator_desc.pDevice = m_device.Get();
-    allocator_desc.pAdapter = m_adapter.Get();
+    allocator_desc.pAdapter = m_adapter->m_adapter.Get();
     allocator_desc.pAllocationCallbacks = &allocation_callbacks;
     chr | CreateAllocator(&allocator_desc, &m_gpu_allocator);
 
@@ -173,6 +76,8 @@ D3d12GpuDevice::D3d12GpuDevice(
     }
 
     chr | m_device->QueryInterface(IID_PPV_ARGS(&m_device0));
+
+    m_descriptor_manager = box<DescriptorManager>(this);
 }
 
 D3d12GpuDevice::~D3d12GpuDevice()
@@ -183,15 +88,31 @@ D3d12GpuDevice::~D3d12GpuDevice()
     }
 }
 
-FResult D3d12GpuDevice::SetName(const Str8or16& name) noexcept
+const Logger& D3d12GpuDevice::Logger() const noexcept
+{
+    return m_instance->Logger();
+}
+
+bool D3d12GpuDevice::Debug() const noexcept
+{
+    return m_instance->Debug();
+}
+
+FResult D3d12GpuDevice::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
-        if (!Debug()) return;
+        if (!Debug())
+            return;
         chr | m_device >> SetNameEx(name);
     });
 }
 
+FGpuAdapter* D3d12GpuDevice::GetAdapter() noexcept
+{
+    return m_adapter.get();
+}
+
 void* D3d12GpuDevice::GetRawDevice() noexcept
 {
     return m_device0.Get();
@@ -200,12 +121,13 @@ void* D3d12GpuDevice::GetRawDevice() noexcept
 
 const Rc<D3d12ShaderLayout>& D3d12GpuDevice::GetEmptyLayout(FShaderLayoutFlags flags)
 {
-    if (!m_empty_layouts) m_empty_layouts = std::make_unique<EmptyLayouts>();
+    if (!m_empty_layouts)
+        m_empty_layouts = std::make_unique<EmptyLayouts>();
     return m_empty_layouts->GetOrAdd(flags, [&](auto& p)
     {
         const auto name = fmt::format(L"Empty Layout {}", static_cast<u32>(flags));
         FShaderLayoutCreateOptions options{};
-        options.Name = Str8or16(name);
+        options.Name = FStr8or16(name);
         options.Flags = flags;
         p = Rc(new D3d12ShaderLayout(this->CloneThis(), options));
     });
@@ -216,7 +138,7 @@ const Rc<D3d12MeshLayout>& D3d12GpuDevice::GetEmptyMeshLayout()
     if (m_empty_mesh_layout == nullptr)
     {
         FMeshLayoutCreateOptions options{};
-        options.Name = Str8or16(L"Empty Mesh Layout");
+        options.Name = FStr8or16(L"Empty Mesh Layout");
         m_empty_mesh_layout = Rc(new D3d12MeshLayout(this->CloneThis(), options));
     }
     return m_empty_mesh_layout;
@@ -246,6 +168,15 @@ FResult D3d12GpuDevice::CreateShaderLayout(const FShaderLayoutCreateOptions& opt
     });
 }
 
+FResult D3d12GpuDevice::GetEmptyShaderLayout(const FGetEmptyShaderLayoutOptions& options, FShaderLayout** out) noexcept
+{
+    return feb([&]
+    {
+        Rc r = GetEmptyLayout(options.Flags);
+        *out = r.leak();
+    });
+}
+
 FResult D3d12GpuDevice::CreateShaderInputLayout(const FShaderInputLayoutCreateOptions& options,
                                                 FShaderInputLayout** out) noexcept
 {
@@ -263,6 +194,14 @@ FResult D3d12GpuDevice::CreateShader(const FShaderCreateOptions& options, FShade
     });
 }
 
+FResult D3d12GpuDevice::CreateShaderBinding(const FShaderBindingCreateOptions& options, FShaderBinding** out) noexcept
+{
+    return feb([&]
+    {
+        *out = new D3d12ShaderBinding(this->CloneThis(), options);
+    });
+}
+
 FResult D3d12GpuDevice::CreateMeshLayout(const FMeshLayoutCreateOptions& options, FMeshLayout** out) noexcept
 {
     return feb([&]
diff --git a/Coplt.Graphics.Native/D3d12/Src/Device.h b/Coplt.Graphics.Native/D3d12/Src/Device.h
index ccb7901..e7bd340 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Device.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Device.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <directx/d3d12.h>
+
 #include "D3D12MemAlloc.h"
 #include "Instance.h"
 #include "../../Api/Include/HashMap.h"
@@ -9,6 +10,8 @@
 
 namespace Coplt
 {
+    struct D3d12GpuAdapter;
+    struct DescriptorManager;
     struct D3d12ShaderLayout;
     struct D3d12MeshLayout;
 
@@ -17,35 +20,27 @@ namespace Coplt
         using EmptyLayouts = HashMap<FShaderLayoutFlags, Rc<D3d12ShaderLayout>>;
 
         Rc<D3d12Instance> m_instance{};
-        ComPtr<ID3D12Debug> m_debug_controller{};
-        ComPtr<IDXGIFactory4> m_factory{};
-        ComPtr<IDXGIAdapter1> m_adapter{};
+        Rc<D3d12GpuAdapter> m_adapter{};
         ComPtr<ID3D12Device2> m_device{};
         ComPtr<ID3D12Device> m_device0{};
         ComPtr<ID3D12InfoQueue1> m_info_queue{};
         ComPtr<D3D12MA::Allocator> m_gpu_allocator{};
-        std::unique_ptr<EmptyLayouts> m_empty_layouts{};
+        Box<DescriptorManager> m_descriptor_manager{};
+        Box<EmptyLayouts> m_empty_layouts{};
         Rc<D3d12MeshLayout> m_empty_mesh_layout{};
         DWORD m_callback_cookie{};
 
-        explicit D3d12GpuDevice(
-            Rc<D3d12Instance> instance,
-            const FGpuDeviceCreateOptions& options
-        );
+        explicit D3d12GpuDevice(Rc<D3d12GpuAdapter>&& adapter, const FGpuDeviceCreateOptions& options);
 
         ~D3d12GpuDevice() override;
 
-        const Logger& Logger() const noexcept
-        {
-            return m_instance->Logger();
-        }
+        const Logger& Logger() const noexcept;
+
+        bool Debug() const noexcept;
 
-        bool Debug() const noexcept
-        {
-            return m_debug_controller != nullptr;
-        }
+        FResult SetName(const FStr8or16& name) noexcept override;
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FGpuAdapter* GetAdapter() noexcept override;
 
         void* GetRawDevice() noexcept override;
 
@@ -56,10 +51,14 @@ namespace Coplt
 
         FResult CreateShaderModule(const FShaderModuleCreateOptions& options, FShaderModule** out) noexcept override;
         FResult CreateShaderLayout(const FShaderLayoutCreateOptions& options, FShaderLayout** out) noexcept override;
+        FResult GetEmptyShaderLayout(
+            const FGetEmptyShaderLayoutOptions& options, FShaderLayout** out
+        ) noexcept override;
         FResult CreateShaderInputLayout(
             const FShaderInputLayoutCreateOptions& options, FShaderInputLayout** out
         ) noexcept override;
         FResult CreateShader(const FShaderCreateOptions& options, FShader** out) noexcept override;
+        FResult CreateShaderBinding(const FShaderBindingCreateOptions& options, FShaderBinding** out) noexcept override;
 
         FResult CreateMeshLayout(const FMeshLayoutCreateOptions& options, FMeshLayout** out) noexcept override;
 
diff --git a/Coplt.Graphics.Native/D3d12/Src/Executor.h b/Coplt.Graphics.Native/D3d12/Src/Executor.h
new file mode 100644
index 0000000..dce292c
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/Executor.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../../Api/FFI/Executor.h"
+
+namespace Coplt
+{
+    struct D3d12GpuQueue;
+
+    COPLT_INTERFACE_DEFINE(ID3d12GpuExecutor, "f9b5793d-b6e9-4b7e-8953-5fa07b815010", FGpuExecutor)
+    {
+        virtual void Submit(D3d12GpuQueue* Queue, const FCommandSubmit* submit) = 0;
+        virtual void SubmitNoWait(D3d12GpuQueue* Queue, const FCommandSubmit* submit) = 0;
+    };
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.cc b/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.cc
index 69da5f2..72d2d78 100644
--- a/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.cc
@@ -131,14 +131,17 @@ D3d12GraphicsShaderPipeline::D3d12GraphicsShaderPipeline(
 ) : m_device(std::move(device)), m_graphics_state(options.GraphicsState)
 {
     m_dx_device = m_device->m_device;
-    if (options.Shader == nullptr) throw WRuntimeException(L"Shader is null");
+    if (options.Shader == nullptr)
+        COPLT_THROW("Shader is null");
     m_shader = Rc<FShader>::UnsafeClone(options.Shader);
-    if (!HasFlags(m_shader->Stages, FShaderStageFlags::Pixel)) throw WRuntimeException(L"The shader is not graphics");
+    if (!HasFlags(m_shader->Stages, FShaderStageFlags::Pixel))
+        COPLT_THROW("The shader is not graphics");
 
     if (auto layout = m_shader->Layout())
     {
         auto dx_layout = layout->QueryInterface<FD3d12ShaderLayout>();
-        if (dx_layout == nullptr) throw WRuntimeException(L"Shader layout from different backends");
+        if (dx_layout == nullptr)
+            COPLT_THROW("Shader layout from different backends");
         m_layout = Rc<FD3d12ShaderLayout>::UnsafeClone(dx_layout);
     }
     else
@@ -173,12 +176,14 @@ D3d12GraphicsShaderPipeline::D3d12GraphicsShaderPipeline(
         if (auto input_layout = m_shader->InputLayout())
         {
             auto dx_input_layout = input_layout->QueryInterface<FD3d12ShaderInputLayout>();
-            if (dx_input_layout == nullptr) throw WRuntimeException(L"Input layout from different backends");
+            if (dx_input_layout == nullptr)
+                COPLT_THROW("Input layout from different backends");
             FD3d12MeshLayout* dx_mesh_layout{};
             if (options.MeshLayout != nullptr)
             {
                 dx_mesh_layout = options.MeshLayout->QueryInterface<FD3d12MeshLayout>();
-                if (dx_mesh_layout == nullptr) throw WRuntimeException(L"Mesh layout from different backends");
+                if (dx_mesh_layout == nullptr)
+                    COPLT_THROW("Mesh layout from different backends");
             }
             else dx_mesh_layout = m_device->GetEmptyMeshLayout().get();
             SetInputLayout(&m_device, tmp_strings, input_element_desc, input_slots, dx_input_layout, dx_mesh_layout);
@@ -204,7 +209,7 @@ D3d12GraphicsShaderPipeline::D3d12GraphicsShaderPipeline(
         desc.Flags = D3D12_PIPELINE_STATE_FLAG_DYNAMIC_DEPTH_BIAS;
         stream = CD3DX12_PIPELINE_STATE_STREAM2(desc);
     }
-    else throw WRuntimeException(L"Unknown shader stage combination");
+    else COPLT_THROW("Unknown shader stage combination");
 
     D3D12_PIPELINE_STATE_STREAM_DESC stream_desc{};
     stream_desc.SizeInBytes = sizeof(stream);
@@ -219,7 +224,7 @@ D3d12GraphicsShaderPipeline::D3d12GraphicsShaderPipeline(
     m_input_slots = std::move(input_slots);
 }
 
-FResult D3d12GraphicsShaderPipeline::SetName(const Str8or16& name) noexcept
+FResult D3d12GraphicsShaderPipeline::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
diff --git a/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.h b/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.h
index 9050ffc..4ae8b3d 100644
--- a/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.h
+++ b/Coplt.Graphics.Native/D3d12/Src/GraphicsPipeline.h
@@ -28,7 +28,7 @@ namespace Coplt
             Rc<D3d12GpuDevice>&& device, const FGraphicsShaderPipelineCreateOptions& options
         );
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         void* GetPipelineStatePtr() noexcept override;
 
diff --git a/Coplt.Graphics.Native/D3d12/Src/Instance.cc b/Coplt.Graphics.Native/D3d12/Src/Instance.cc
index 1c2acbe..88cec45 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Instance.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Instance.cc
@@ -1,14 +1,118 @@
 #include "Instance.h"
 
-#include "Device.h"
 #include "../../Api/Include/Error.h"
+#include "Adapter.h"
+#include "Device.h"
 
 using namespace Coplt;
 
-FResult D3d12Instance::CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept
+D3d12Instance::D3d12Instance(const FInstanceCreateOptions& options)
+{
+    UINT dxgi_flags = 0;
+
+    if (options.Debug)
+    {
+        if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&m_debug_controller))))
+        {
+            m_debug_controller->EnableDebugLayer();
+            dxgi_flags |= DXGI_CREATE_FACTORY_DEBUG;
+            m_debug_enabled = true;
+
+            if (options.GpuBasedValidation)
+            {
+                ComPtr<ID3D12Debug1> debug1{};
+                if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug1>(&debug1)))
+                {
+                    debug1->SetEnableGPUBasedValidation(true);
+                    m_gpu_based_validation_enabled = true;
+                }
+                ComPtr<ID3D12Debug2> debug2{};
+                if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug2>(&debug2)))
+                {
+                    debug2->SetGPUBasedValidationFlags(D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING);
+                }
+            }
+
+            ComPtr<ID3D12Debug5> debug5{};
+            if (SUCCEEDED(m_debug_controller->QueryInterface<ID3D12Debug5>(&debug5)))
+            {
+                debug5->SetEnableAutoName(true);
+            }
+        }
+        else
+            m_debug_controller = nullptr;
+    }
+
+    chr | CreateDXGIFactory2(dxgi_flags, IID_PPV_ARGS(&m_factory));
+
+    if (SUCCEEDED(m_factory->QueryInterface(IID_PPV_ARGS(&m_factory6))))
+    {
+        ComPtr<IDXGIAdapter1> adapter{};
+        constexpr auto preference = DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE;
+        for (
+            UINT index = 0;
+            SUCCEEDED(m_factory6->EnumAdapterByGpuPreference(index, preference, IID_PPV_ARGS(&adapter)));
+            ++index
+        )
+        {
+            CreateAdapter(std::move(adapter));
+        }
+    }
+    else
+    {
+        ComPtr<IDXGIAdapter1> adapter{};
+        for (UINT index = 0; SUCCEEDED(m_factory->EnumAdapters1(index, &adapter)); ++index)
+        {
+            CreateAdapter(std::move(adapter));
+        }
+    }
+
+    m_f_adapters.reserve(m_adapters.size());
+    for (const auto& adapter : m_adapters)
+        m_f_adapters.push_back(adapter.get());
+}
+
+void D3d12Instance::CreateAdapter(ComPtr<IDXGIAdapter1>&& adapter)
+{
+    m_adapters.push_back(new D3d12GpuAdapter(this->CloneThis(), std::move(adapter)));
+}
+
+FResult D3d12Instance::CreateDevice(const FGpuAutoSelectDeviceCreateOptions& options, FGpuDevice** out) noexcept
 {
     return feb([&]
     {
-        *out = new D3d12GpuDevice(this->CloneThis(), options);
+        FResult ret = FResult::None();
+        std::vector<FResult> results{};
+        for (const auto& adapter : m_adapters)
+        {
+            if (!adapter->IsSupport(options.Requires))
+                continue;
+            auto r = feb([&]
+            {
+                *out = new D3d12GpuDevice(adapter.Clone(), options);
+            });
+            if (!r.IsError())
+                goto end;
+            results.push_back(r);
+        }
+        for (auto& result : results)
+        {
+            Logger().Log(FLogLevel::Error, FLogType::Common, result.msg);
+        }
+        if (m_adapters.empty())
+            Logger().Log(FLogLevel::Error, FLogType::Common, u"No physical gpu device is available.");
+        ret = FResult::Error(u"Creation failed. No matching device.");
+    end:
+        for (auto& result : results)
+        {
+            result.Drop();
+        }
+        return ret;
     });
 }
+
+FGpuAdapter* const* D3d12Instance::GetAdapters(u32* out_count) noexcept
+{
+    *out_count = m_f_adapters.size();
+    return m_f_adapters.data();
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Instance.h b/Coplt.Graphics.Native/D3d12/Src/Instance.h
index e86f6fe..5c0dfc3 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Instance.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Instance.h
@@ -1,16 +1,35 @@
 #pragma once
 
+#include <dxgi1_4.h>
+#include <dxgi1_6.h>
+#include <directx/d3d12.h>
+
 #include "../../Api/Include/Object.h"
 #include "../../Api/FFI/Instance.h"
 #include "../../Api/Include/InstanceBase.h"
 #include "../FFI/Instance.h"
 #include "../Include/Utils.h"
-#include <directx/d3d12.h>
 
 namespace Coplt
 {
+    struct D3d12GpuAdapter;
+
     struct D3d12Instance final : InstanceBase<Object<D3d12Instance, FD3d12Instance>>
     {
-        FResult CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept override;
+        ComPtr<ID3D12Debug> m_debug_controller{};
+        ComPtr<IDXGIFactory4> m_factory{};
+        ComPtr<IDXGIFactory6> m_factory6{};
+        std::vector<Rc<D3d12GpuAdapter>> m_adapters{};
+        std::vector<FGpuAdapter*> m_f_adapters{};
+
+        explicit D3d12Instance(const FInstanceCreateOptions& options);
+
+        void CreateAdapter(ComPtr<IDXGIAdapter1>&& adapter);
+
+        FResult CreateDevice(const FGpuAutoSelectDeviceCreateOptions& options, FGpuDevice** out) noexcept override;
+
+        FGpuAdapter* const* GetAdapters(u32* out_count) noexcept override;
+
+        bool Debug() const noexcept { return m_debug_enabled; }
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Layout.cc b/Coplt.Graphics.Native/D3d12/Src/Layout.cc
index f37db41..31b0793 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Layout.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Layout.cc
@@ -26,13 +26,13 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
         if (item.View == FShaderLayoutItemView::Constants)
         {
             if (item.Type != FShaderLayoutItemType::ConstantBuffer)
-                throw WRuntimeException(L"Push Const / Root Const view must be ConstantBuffer");
+                COPLT_THROW("Push Const / Root Const view must be ConstantBuffer");
 
             D3D12_ROOT_PARAMETER1 param{};
             param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
             param.Constants.ShaderRegister = item.Slot;
             param.Constants.RegisterSpace = item.Space;
-            param.Constants.Num32BitValues = item.CountOrIndex;
+            param.Constants.Num32BitValues = std::max(1u, item.CountOrIndex);
             param.ShaderVisibility = ToDxVisibility(item.Stage);
             m_item_metas[i] = ItemMeta{.Index = static_cast<u32>(root_parameters.size()), .Type = ItemType::Const};
             root_parameters.push_back(param);
@@ -68,14 +68,12 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
                 type = D3D12_ROOT_PARAMETER_TYPE_UAV;
                 goto DefineDescriptor;
             case FShaderLayoutItemView::Sampler:
-                throw WRuntimeException(L"TODO"); // 静态采样器
+                COPLT_THROW("TODO"); // 静态采样器
             default:
-                throw WRuntimeException(
-                    fmt::format(L"Unknown shader layout item type {}", static_cast<u32>(item.Type))
-                );
+                COPLT_THROW_FMT("Unknown shader layout item type {}", static_cast<u32>(item.Type));
             }
         default:
-            throw WRuntimeException(fmt::format(L"Unknown shader layout item usage {}", static_cast<u32>(item.Usage)));
+            COPLT_THROW_FMT("Unknown shader layout item usage {}", static_cast<u32>(item.Usage));
         }
 
         continue;
@@ -116,15 +114,13 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
                 range_type = RangeType::Sampler;
                 break;
             default:
-                throw WRuntimeException(
-                    fmt::format(L"Unknown shader layout item type {}", static_cast<u32>(item.Type))
-                );
+                COPLT_THROW_FMT("Unknown shader layout item type {}", static_cast<u32>(item.Type));
             }
             auto& meta = table.GetOrAdd(TableKey(item.Stage, range_type), [&](auto& p)
             {
                 p = TableMeta(table_index[static_cast<u8>(table_scope)]++, item.Stage, range_type);
             });
-            range.NumDescriptors = item.CountOrIndex;
+            range.NumDescriptors = std::max(1u, item.CountOrIndex);
             range.BaseShaderRegister = item.Slot;
             range.RegisterSpace = item.Space;
             range.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
@@ -197,7 +193,7 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
     }
 }
 
-FResult D3d12ShaderLayout::SetName(const Str8or16& name) noexcept
+FResult D3d12ShaderLayout::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
@@ -217,6 +213,16 @@ const FShaderLayoutItemDefine* D3d12ShaderLayout::GetItemDefines(u32* out_count)
     return m_layout_item_defines.data();
 }
 
+std::span<ID3d12ShaderLayout::ItemMeta> D3d12ShaderLayout::GetItemMetas() noexcept
+{
+    return m_item_metas;
+}
+
+std::array<std::span<ID3d12ShaderLayout::TableMeta>, 2> D3d12ShaderLayout::GetTableMetas() noexcept
+{
+    return std::array<std::span<TableMeta>, 2>{m_table_metas[0], m_table_metas[1]};
+}
+
 D3d12ShaderInputLayout::D3d12ShaderInputLayout(
     Rc<D3d12GpuDevice>&& device, const FShaderInputLayoutCreateOptions& options
 ) : m_device(std::move(device))
@@ -231,7 +237,7 @@ D3d12ShaderInputLayout::D3d12ShaderInputLayout(
     }
 }
 
-FResult D3d12ShaderInputLayout::SetName(const Str8or16& name) noexcept
+FResult D3d12ShaderInputLayout::SetName(const FStr8or16& name) noexcept
 {
     return FResult::None();
 }
@@ -249,23 +255,23 @@ D3d12MeshLayout::D3d12MeshLayout(Rc<D3d12GpuDevice>&& device, const FMeshLayoutC
     m_elements = std::vector(options.Elements, options.Elements + options.ElementCount);
     // 保留 1 个 slot 永远为 0
     if (m_buffers.size() >= 31)
-        throw WRuntimeException(
-            fmt::format(
-                L"Too many buffers, a maximum of 31 buffers are supported, but actually provided {}",
-                m_buffers.size()
-            )
+    {
+        COPLT_THROW_FMT(
+            "Too many buffers, a maximum of 31 buffers are supported, but actually provided {}",
+            m_buffers.size()
         );
+    }
     for (u32 i = 0; i < m_elements.size(); ++i)
     {
         const auto& element = m_elements[i];
         const auto key = static_cast<u64>(element.SlotId) | (static_cast<u64>(element.SlotIndex) << 32);
         m_slot_id_index_to_element.TryAdd(key, &element);
         if (element.BufferIndex > m_buffers.size())
-            throw WRuntimeException(fmt::format(L"BufferIndex of element {} is out of range", i));
+            COPLT_THROW_FMT("BufferIndex of element {} is out of range", i);
     }
 }
 
-FResult D3d12MeshLayout::SetName(const Str8or16& name) noexcept
+FResult D3d12MeshLayout::SetName(const FStr8or16& name) noexcept
 {
     return FResult::None();
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Layout.h b/Coplt.Graphics.Native/D3d12/Src/Layout.h
index bf9ab46..7b5e2fd 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Layout.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Layout.h
@@ -11,7 +11,7 @@
 
 namespace Coplt
 {
-    struct D3d12ShaderLayout final : Object<D3d12ShaderLayout, FD3d12ShaderLayout>
+    COPLT_INTERFACE_DEFINE(ID3d12ShaderLayout, "d8cea40e-7b0c-4a5f-98a9-88fd3abf9ddc", FD3d12ShaderLayout)
     {
         enum class ItemType : u8
         {
@@ -90,21 +90,31 @@ namespace Coplt
             RangeType RangeType{};
         };
 
+        virtual std::span<ItemMeta> GetItemMetas() noexcept = 0;
+        virtual std::array<std::span<TableMeta>, 2> GetTableMetas() noexcept = 0;
+    };
+
+    struct D3d12ShaderLayout final : Object<D3d12ShaderLayout, ID3d12ShaderLayout>
+    {
         Rc<D3d12GpuDevice> m_device{};
         ComPtr<ID3D12Device2> m_dx_device{};
         ComPtr<ID3D12RootSignature> m_root_signature{};
         std::vector<FShaderLayoutItemDefine> m_layout_item_defines{};
+        // 长度和 m_layout_item_defines 相同
         std::vector<ItemMeta> m_item_metas{};
         // [Common, Material]
         std::vector<TableMeta> m_table_metas[2]{};
 
         explicit D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderLayoutCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         void* GetRootSignaturePtr() noexcept override;
 
         const FShaderLayoutItemDefine* GetItemDefines(u32* out_count) noexcept override;
+
+        std::span<ItemMeta> GetItemMetas() noexcept override;
+        std::array<std::span<TableMeta>, 2> GetTableMetas() noexcept override;
     };
 
     struct D3d12ShaderInputLayout final : Object<D3d12ShaderInputLayout, FD3d12ShaderInputLayout>
@@ -115,7 +125,7 @@ namespace Coplt
 
         explicit D3d12ShaderInputLayout(Rc<D3d12GpuDevice>&& device, const FShaderInputLayoutCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         const FShaderInputLayoutElement* GetElements(u32* out_count) noexcept override;
     };
@@ -129,7 +139,7 @@ namespace Coplt
 
         explicit D3d12MeshLayout(Rc<D3d12GpuDevice>&& device, const FMeshLayoutCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         const FMeshBufferDefine* GetBuffers(u32* out_count) const noexcept override;
         const FMeshBufferElement* GetElements(u32* out_count) const noexcept override;
diff --git a/Coplt.Graphics.Native/D3d12/Src/Library.cc b/Coplt.Graphics.Native/D3d12/Src/Library.cc
index 894795e..07948fd 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Library.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Library.cc
@@ -9,7 +9,10 @@
 
 using namespace Coplt;
 
-FInstance* Coplt_Graphics_D3d12_Create_Instance()
+void Coplt_Graphics_D3d12_Create_Instance(FResult* r, const FInstanceCreateOptions& options, FInstance** out)
 {
-    return new D3d12Instance();
+    *r = feb([&]
+    {
+        *out = new D3d12Instance(options);
+    });
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Output.cc b/Coplt.Graphics.Native/D3d12/Src/Output.cc
index 803f64b..351a689 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Output.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Output.cc
@@ -10,13 +10,19 @@ using namespace Coplt;
 D3d12GpuSwapChainOutput::D3d12GpuSwapChainOutput(Rc<D3d12GpuQueue>&& queue) : m_queue(std::move(queue))
 {
     if (m_queue->m_queue_type != FGpuQueueType::Direct)
-        throw WRuntimeException(L"Cannot create output on a non direct queue.");
+        COPLT_THROW("Cannot create output on a non direct queue.");
 
     m_device = m_queue->m_device;
     m_dx_device = m_queue->m_dx_device;
     m_dx_queue = m_queue->m_queue;
 
-    m_state = FResourceState::Present;
+    m_state = {
+        .Access = FResAccess::NoAccess,
+        .Layout = FResLayout::Present,
+        .Stages = FShaderStageFlags::None,
+        .Legacy = FLegacyState::Present,
+        .CrossQueue = true,
+    };
 }
 
 D3d12GpuSwapChainOutput::D3d12GpuSwapChainOutput(Rc<D3d12GpuQueue>&& queue, const FGpuOutputCreateOptions& options)
@@ -130,7 +136,7 @@ D3d12GpuSwapChainOutput::D3d12GpuSwapChainOutput(
     }
 
     ComPtr<IDXGISwapChain1> swap_chain;
-    chr | m_device->m_factory->CreateSwapChainForHwnd(
+    chr | m_device->m_instance->m_factory->CreateSwapChainForHwnd(
         m_dx_queue.Get(),
         hwnd,
         &desc,
@@ -174,7 +180,7 @@ FGraphicsFormat D3d12GpuSwapChainOutput::SelectFormat(
     return FGraphicsFormat::R8G8B8A8_UNorm;
 }
 
-FResult D3d12GpuSwapChainOutput::SetName(const Str8or16& name) noexcept
+FResult D3d12GpuSwapChainOutput::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
@@ -214,34 +220,32 @@ FResult D3d12GpuSwapChainOutput::Resize(const u32 Width, const u32 Height) noexc
     });
 }
 
-FResult D3d12GpuSwapChainOutput::Present(/* 可选 */ const FCommandSubmit* submit) noexcept
+FResult D3d12GpuSwapChainOutput::Wait() noexcept
 {
     return feb([&]
     {
         std::lock_guard lock(m_queue->m_mutex);
-        Submit_NoLock(submit);
-        Present_NoLock();
         WaitNextFrame_NoLock();
     });
 }
 
-FResult D3d12GpuSwapChainOutput::PresentNoWait(/* 可选 */ const FCommandSubmit* submit) noexcept
+void D3d12GpuSwapChainOutput::Submit(D3d12GpuQueue* Queue, const FCommandSubmit* submit)
 {
-    return feb([&]
-    {
-        std::lock_guard lock(m_queue->m_mutex);
-        Submit_NoLock(submit);
-        Present_NoLock();
-    });
+    if (Queue != m_queue)
+        COPLT_THROW("The executor does not belong to this queue");
+    std::lock_guard lock(m_queue->m_mutex);
+    Submit_NoLock(submit);
+    Present_NoLock();
+    WaitNextFrame_NoLock();
 }
 
-FResult D3d12GpuSwapChainOutput::WaitNextFrame() noexcept
+void D3d12GpuSwapChainOutput::SubmitNoWait(D3d12GpuQueue* Queue, const FCommandSubmit* submit)
 {
-    return feb([&]
-    {
-        std::lock_guard lock(m_queue->m_mutex);
-        WaitNextFrame_NoLock();
-    });
+    if (Queue != m_queue)
+        COPLT_THROW("The executor does not belong to this queue");
+    std::lock_guard lock(m_queue->m_mutex);
+    Submit_NoLock(submit);
+    Present_NoLock();
 }
 
 void D3d12GpuSwapChainOutput::Submit_NoLock(const FCommandSubmit* submit)
@@ -358,7 +362,7 @@ FResult D3d12GpuSwapChainOutput::GetCurrentRtv(void* out) noexcept
     return feb([&]
     {
         CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(m_rtv_heap->GetCPUDescriptorHandleForHeapStart());
-        rtv_handle.Offset(m_frame_index, m_rtv_descriptor_size);
+        rtv_handle.Offset(static_cast<i32>(m_frame_index), m_rtv_descriptor_size);
         *static_cast<D3D12_CPU_DESCRIPTOR_HANDLE*>(out) = rtv_handle;
     });
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Output.h b/Coplt.Graphics.Native/D3d12/Src/Output.h
index d1e5e1c..471d87b 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Output.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Output.h
@@ -4,6 +4,7 @@
 #include <dxgi1_4.h>
 
 #include "Context.h"
+#include "Executor.h"
 #include "Queue.h"
 #include "../FFI/Output.h"
 #include "../../Api/Include/Object.h"
@@ -12,7 +13,7 @@ namespace Coplt
 {
     struct D3d12GpuDevice;
 
-    struct D3d12GpuSwapChainOutput final : Object<D3d12GpuSwapChainOutput, FD3d12GpuSwapChainOutput>
+    struct D3d12GpuSwapChainOutput final : Object<D3d12GpuSwapChainOutput, FD3d12GpuSwapChainOutput, ID3d12GpuExecutor>
     {
         constexpr static UINT MaxBufferCount = 3;
 
@@ -55,15 +56,16 @@ namespace Coplt
 
         static FGraphicsFormat SelectFormat(const FGpuOutputCreateOptions& options, bool& is_hdr);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         FResult SetVSync(b8 Enable) noexcept override;
 
         FResult Resize(u32 Width, u32 Height) noexcept override;
 
-        FResult Present(/* 可选 */ const FCommandSubmit* submit) noexcept override;
-        FResult PresentNoWait(/* 可选 */ const FCommandSubmit* submit) noexcept override;
-        FResult WaitNextFrame() noexcept override;
+        FResult Wait() noexcept override;
+
+        void Submit(D3d12GpuQueue* Queue, const FCommandSubmit* submit) override;
+        void SubmitNoWait(D3d12GpuQueue* Queue, const FCommandSubmit* submit) override;
 
         void Submit_NoLock(/* 可选 */ const FCommandSubmit* submit);
         void Present_NoLock();
diff --git a/Coplt.Graphics.Native/D3d12/Src/Queue.cc b/Coplt.Graphics.Native/D3d12/Src/Queue.cc
index a247320..02644e3 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Queue.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Queue.cc
@@ -41,7 +41,7 @@ D3d12GpuQueue::D3d12GpuQueue(
     }
 }
 
-FResult D3d12GpuQueue::SetName(const Str8or16& name) noexcept
+FResult D3d12GpuQueue::SetName(const FStr8or16& name) noexcept
 {
     return feb([&]
     {
@@ -114,3 +114,25 @@ void D3d12GpuQueue::SubmitNoLock(
     m_context = m_frame_context.get();
     m_submit_id++;
 }
+
+FResult D3d12GpuQueue::Submit(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept
+{
+    return feb([&]
+    {
+        const auto executor = Executor->QueryInterface<ID3d12GpuExecutor>();
+        if (executor == nullptr)
+            COPLT_THROW("Executors from different backends");
+        executor->Submit(this, submit);
+    });
+}
+
+FResult D3d12GpuQueue::SubmitNoWait(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept
+{
+    return feb([&]
+    {
+        const auto executor = Executor->QueryInterface<ID3d12GpuExecutor>();
+        if (executor == nullptr)
+            COPLT_THROW("Executors from different backends");
+        executor->SubmitNoWait(this, submit);
+    });
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Queue.h b/Coplt.Graphics.Native/D3d12/Src/Queue.h
index fcee695..4208ae3 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Queue.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Queue.h
@@ -9,6 +9,7 @@
 #include "../../Api/Include/Object.h"
 #include "../FFI/Queue.h"
 #include "Command.h"
+#include "Executor.h"
 
 namespace Coplt
 {
@@ -27,7 +28,7 @@ namespace Coplt
 
         explicit D3d12GpuQueue(Rc<D3d12GpuDevice>&& device, const FMainQueueCreateOptions& options);
 
-        FResult SetName(const Str8or16& name) noexcept override;
+        FResult SetName(const FStr8or16& name) noexcept override;
 
         void* GetRawQueue() noexcept override;
 
@@ -49,6 +50,9 @@ namespace Coplt
         void Submit(Rc<D3d12FrameContext>& frame_context, /* 可选 */ const FCommandSubmit* submit);
         // 提交命令，并互换帧上下文，但是无锁，需要外部手动锁，参数提供的帧上下文必须可用
         void SubmitNoLock(Rc<D3d12FrameContext>& frame_context, /* 可选 */ const FCommandSubmit* submit);
+
+        FResult Submit(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept override;
+        FResult SubmitNoWait(FGpuExecutor* Executor, const FCommandSubmit* submit) noexcept override;
     };
 
     inline D3D12_COMMAND_LIST_TYPE ToDx(const FGpuQueueType value)
diff --git a/Coplt.Graphics.Native/D3d12/Src/Resource.cc b/Coplt.Graphics.Native/D3d12/Src/Resource.cc
index 31d7bb8..3e807e9 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Resource.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Resource.cc
@@ -1,54 +1,71 @@
 #include "Resource.h"
 
+#include "Adapter.h"
+#include "../ThirdParty/DirectXTK12/Src/d3dx12.h"
+
 using namespace Coplt;
 
 ResourcePack::ResourcePack(
-    D3D12MA::Allocator* allocator, const FCpuAccess cpu_access, FResourceState& state,
-    const D3D12_RESOURCE_DESC* desc, const D3D12_CLEAR_VALUE* clear_value
+    D3d12GpuDevice* device, D3D12MA::Allocator* allocator, const FCpuAccess cpu_access,
+    FResState& state, const D3D12_RESOURCE_DESC1* desc, const D3D12_CLEAR_VALUE* clear_value
 )
 {
     D3D12MA::ALLOCATION_DESC alloc_desc{};
     alloc_desc.Flags = D3D12MA::ALLOCATION_FLAG_NONE;
+
     D3D12_RESOURCE_STATES init_state{};
     switch (cpu_access)
     {
     case FCpuAccess::Write:
         alloc_desc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
         init_state = D3D12_RESOURCE_STATE_GENERIC_READ;
-        state = FResourceState::GenericRead;
+        state = FResState::BufferGenericRead();
         break;
     case FCpuAccess::Read:
         alloc_desc.HeapType = D3D12_HEAP_TYPE_READBACK;
         init_state = D3D12_RESOURCE_STATE_COPY_DEST;
-        state = FResourceState::CopyDst;
+        state = FResState::BufferCopyDst();
         break;
     default:
         alloc_desc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
         init_state = D3D12_RESOURCE_STATE_COMMON;
-        state = FResourceState::Common;
+        state = FResState::BufferCommon();
         break;
     }
-    chr | allocator->CreateResource(
-        &alloc_desc, desc, init_state, clear_value, &m_allocation, IID_PPV_ARGS(&m_resource)
-    );
+
+    if (device->m_adapter->m_features.EnhancedBarriers)
+    {
+        chr | allocator->CreateResource3(
+            &alloc_desc, desc, D3D12_BARRIER_LAYOUT_UNDEFINED, clear_value,
+            0, nullptr, &m_allocation, IID_PPV_ARGS(&m_resource)
+        );
+    }
+    else
+    {
+        D3D12_RESOURCE_DESC desc0{};
+        desc0.Dimension = desc->Dimension;
+        desc0.Alignment = desc->Alignment;
+        desc0.Width = desc->Width;
+        desc0.Height = desc->Height;
+        desc0.DepthOrArraySize = desc->DepthOrArraySize;
+        desc0.MipLevels = desc->MipLevels;
+        desc0.Format = desc->Format;
+        desc0.SampleDesc = desc->SampleDesc;
+        desc0.Layout = desc->Layout;
+        desc0.Flags = desc->Flags;
+
+
+        chr | allocator->CreateResource(
+            &alloc_desc, &desc0, init_state, clear_value, &m_allocation, IID_PPV_ARGS(&m_resource)
+        );
+    }
 }
 
 BufferPack::BufferPack(
-    D3D12MA::Allocator* allocator, const FCpuAccess cpu_access, const u64 size,
-    const D3D12_RESOURCE_FLAGS Flags
+    D3d12GpuDevice* device, D3D12MA::Allocator* allocator, FCpuAccess cpu_access,
+    const u64 size, const D3D12_RESOURCE_FLAGS Flags
 ) : m_size(size)
 {
-    D3D12_RESOURCE_DESC desc{};
-    desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
-    desc.Alignment = 0;
-    desc.Width = size;
-    desc.Height = 1;
-    desc.DepthOrArraySize = 1;
-    desc.MipLevels = 1;
-    desc.Format = DXGI_FORMAT_UNKNOWN;
-    desc.SampleDesc.Count = 1;
-    desc.SampleDesc.Quality = 0;
-    desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-    desc.Flags = Flags;
-    m_resource = ResourcePack(allocator, cpu_access, m_state, &desc, nullptr);
+    const auto desc = CD3DX12_RESOURCE_DESC1::Buffer(size, Flags);
+    m_resource = ResourcePack(device, allocator, cpu_access, m_state, &desc, nullptr);
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Resource.h b/Coplt.Graphics.Native/D3d12/Src/Resource.h
index 4fb53dd..2f25f49 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Resource.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Resource.h
@@ -14,8 +14,8 @@ namespace Coplt
         ResourcePack() = default;
 
         explicit ResourcePack(
-            D3D12MA::Allocator* allocator, FCpuAccess cpu_access, FResourceState& state,
-            const D3D12_RESOURCE_DESC* desc, const D3D12_CLEAR_VALUE* clear_value
+            D3d12GpuDevice* device, D3D12MA::Allocator* allocator, FCpuAccess cpu_access,
+            FResState& state, const D3D12_RESOURCE_DESC1* desc, const D3D12_CLEAR_VALUE* clear_value
         );
     };
 
@@ -23,13 +23,13 @@ namespace Coplt
     {
         ResourcePack m_resource{};
         u64 m_size{};
-        FResourceState m_state{};
+        FResState m_state{};
 
         BufferPack() = default;
 
         explicit BufferPack(
-            D3D12MA::Allocator* allocator, FCpuAccess cpu_access, u64 size,
-            D3D12_RESOURCE_FLAGS Flags = D3D12_RESOURCE_FLAG_NONE
+            D3d12GpuDevice* device, D3D12MA::Allocator* allocator, FCpuAccess cpu_access,
+            u64 size, D3D12_RESOURCE_FLAGS Flags = D3D12_RESOURCE_FLAG_NONE
         );
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers b/Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers
index 44432a5..1b3e307 160000
--- a/Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/DirectX-Headers
@@ -1 +1 @@
-Subproject commit 44432a5fb04c566ccda7a6079488bd84b7b61ec8
+Subproject commit 1b3e307de44806825dbad2fc66762b61d7df4ec4
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/DirectXTK12 b/Coplt.Graphics.Native/D3d12/ThirdParty/DirectXTK12
index 67f9877..72a6c4b 160000
--- a/Coplt.Graphics.Native/D3d12/ThirdParty/DirectXTK12
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/DirectXTK12
@@ -1 +1 @@
-Subproject commit 67f987722b9eef4c2af96a4bb9abe1cc602d869c
+Subproject commit 72a6c4bbf122c603f2090a7afa4c72fadb797656
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h
new file mode 100644
index 0000000..1a9fdf0
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h
@@ -0,0 +1,1578 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Don't include this file directly - use pix3.h
+
+#pragma once
+
+#ifndef _PixEvents_H_
+#define _PixEvents_H_
+
+#ifndef _PIX3_H_
+# error Do not include this file directly - use pix3.h
+#endif
+
+#include "PIXEventsCommon.h"
+
+#if _MSC_VER < 1800
+# error This version of pix3.h is only supported on Visual Studio 2013 or higher
+#elif _MSC_VER < 1900
+# ifndef constexpr // Visual Studio 2013 doesn't support constexpr
+#  define constexpr
+#  define PIX3__DEFINED_CONSTEXPR
+# endif
+#endif
+
+ // Xbox does not support CPU events for retail scenarios
+#if defined(USE_PIX) || !defined(PIX_XBOX)
+#define PIX_CONTEXT_EMIT_CPU_EVENTS
+#endif
+
+namespace PIXEventsDetail
+{
+    inline void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit)
+    {
+        // nothing
+        UNREFERENCED_PARAMETER(destination);
+        UNREFERENCED_PARAMETER(limit);
+    }
+
+    template<typename ARG, typename... ARGS>
+    void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args)
+    {
+        PIXCopyEventArgument(destination, limit, arg);
+        PIXCopyEventArguments(destination, limit, args...);
+    }
+
+    template<typename ARG, typename... ARGS>
+    void PIXCopyStringArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args)
+    {
+        PIXCopyStringArgument(destination, limit, arg);
+        PIXCopyEventArguments(destination, limit, args...);
+    }
+
+    template<typename ARG, typename... ARGS>
+    void PIXCopyStringArgumentsWithContext(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, void* context, ARG const& arg, ARGS const&... args)
+    {
+#ifdef PIX_XBOX
+        UNREFERENCED_PARAMETER(context);
+        PIXCopyStringArgument(destination, limit, arg);
+        PIXCopyEventArguments(destination, limit, args...);
+#else
+        PIXCopyEventArgument(destination, limit, context);
+        PIXCopyStringArgument(destination, limit, arg);
+        PIXCopyEventArguments(destination, limit, args...);
+#endif
+    }
+
+    inline UINT8 PIXGetEventSize(const UINT64* end, const UINT64* start)
+    {
+        const UINT64 actualEventSize = end - start;
+
+        return static_cast<UINT8>(actualEventSize > PIXEventsSizeMax ? PIXEventsSizeMax : actualEventSize);
+    }
+
+    template<typename STR>
+    inline UINT8 PIXEncodeStringIsAnsi()
+    {
+        return PIX_EVENT_METADATA_NONE;
+    }
+
+    template<>
+    inline UINT8 PIXEncodeStringIsAnsi<char*>()
+    {
+        return PIX_EVENT_METADATA_STRING_IS_ANSI;
+    }
+
+    template<>
+    inline UINT8 PIXEncodeStringIsAnsi<const char*>()
+    {
+        return PIX_EVENT_METADATA_STRING_IS_ANSI;
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXBeginEventAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+            return;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+        if (destination >= limit)
+            return;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        UINT64* eventDestination = destination++;
+        *destination++ = color;
+
+        PIXCopyStringArguments(destination, limit, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIX_EVENT_METADATA_HAS_COLOR |
+            PIXEncodeStringIsAnsi<STR>();
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXBeginEvent(UINT64 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                UINT64* eventDestination = destination++;
+                *destination++ = color;
+
+                PIXCopyStringArguments(destination, limit, formatString, args...);
+                *destination = PIXEventsBlockEndMarker;
+
+                const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+                const UINT8 eventMetadata =
+                    PIX_EVENT_METADATA_HAS_COLOR |
+                    PIXEncodeStringIsAnsi<STR>();
+                *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+                threadInfo->destination = destination;
+            }
+            else
+            {
+                PIXBeginEventAllocate(threadInfo, color, formatString, args...);
+            }
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXBeginEventAllocate(PIXEventsThreadInfo* threadInfo, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+            return;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+        if (destination >= limit)
+            return;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        UINT64* eventDestination = destination++;
+
+        PIXCopyStringArguments(destination, limit, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIXEncodeStringIsAnsi<STR>() |
+            PIXEncodeIndexColor(color);
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXBeginEvent(UINT8 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                UINT64* eventDestination = destination++;
+
+                PIXCopyStringArguments(destination, limit, formatString, args...);
+                *destination = PIXEventsBlockEndMarker;
+
+                const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+                const UINT8 eventMetadata =
+                    PIXEncodeStringIsAnsi<STR>() |
+                    PIXEncodeIndexColor(color);
+                *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+                threadInfo->destination = destination;
+            }
+            else
+            {
+                PIXBeginEventAllocate(threadInfo, color, formatString, args...);
+            }
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXSetMarkerAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+            return;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+            return;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        UINT64* eventDestination = destination++;
+        *destination++ = color;
+
+        PIXCopyStringArguments(destination, limit, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIXEncodeStringIsAnsi<STR>() |
+            PIX_EVENT_METADATA_HAS_COLOR;
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXSetMarker(UINT64 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                UINT64* eventDestination = destination++;
+                *destination++ = color;
+
+                PIXCopyStringArguments(destination, limit, formatString, args...);
+                *destination = PIXEventsBlockEndMarker;
+
+                const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+                const UINT8 eventMetadata =
+                    PIXEncodeStringIsAnsi<STR>() |
+                    PIX_EVENT_METADATA_HAS_COLOR;
+                *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+                threadInfo->destination = destination;
+            }
+            else
+            {
+                PIXSetMarkerAllocate(threadInfo, color, formatString, args...);
+            }
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXSetMarkerAllocate(PIXEventsThreadInfo* threadInfo, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+            return;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+            return;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        UINT64* eventDestination = destination++;
+
+        PIXCopyStringArguments(destination, limit, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIXEncodeStringIsAnsi<STR>() |
+            PIXEncodeIndexColor(color);
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXSetMarker(UINT8 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                UINT64* eventDestination = destination++;
+
+                PIXCopyStringArguments(destination, limit, formatString, args...);
+                *destination = PIXEventsBlockEndMarker;
+
+                const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+                const UINT8 eventMetadata =
+                    PIXEncodeStringIsAnsi<STR>() |
+                    PIXEncodeIndexColor(color);
+                *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+                threadInfo->destination = destination;
+            }
+            else
+            {
+                PIXSetMarkerAllocate(threadInfo, color, formatString, args...);
+            }
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXBeginEventOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        eventDestination = destination++;
+        *destination++ = color;
+
+        PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIX_EVENT_METADATA_ON_CONTEXT |
+            PIXEncodeStringIsAnsi<STR>() |
+            PIX_EVENT_METADATA_HAS_COLOR;
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXBeginEventOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit == nullptr)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        if (destination < limit)
+        {
+            limit += PIXEventsSafeFastCopySpaceQwords;
+            UINT64 time = PIXGetTimestampCounter();
+            eventDestination = destination++;
+            *destination++ = color;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = PIXEventsBlockEndMarker;
+
+            eventSize = PIXGetEventSize(destination, threadInfo->destination);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIX_EVENT_METADATA_HAS_COLOR;
+            *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+            threadInfo->destination = destination;
+        }
+        else
+        {
+            PIXBeginEventOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...);
+        }
+    }
+
+    template<typename CONTEXT, typename STR, typename... ARGS>
+    void PIXBeginEvent(CONTEXT* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = nullptr;
+        UINT8 eventSize = 0u;
+
+#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS
+        PIXBeginEventOnContextCpu(destination, eventSize, context, color, formatString, args...);
+#endif
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+        if (destination != nullptr)
+        {
+            PIXInsertTimingMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast<void*>(destination), eventSize * sizeof(UINT64));
+        }
+        else
+#endif
+        {
+            UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords];
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+            destination = buffer;
+            UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+            UINT64* eventDestination = destination++;
+            *destination++ = color;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = 0ull;
+
+            eventSize = static_cast<const UINT8>(destination - buffer);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIX_EVENT_METADATA_HAS_COLOR;
+            *eventDestination = PIXEncodeEventInfo(0, PIXEvent_BeginEvent, eventSize, eventMetadata);
+            PIXInsertGPUMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#else
+            destination = PixEventsLegacy::EncodeBeginEventForContext(buffer, color, formatString, args...);
+            PIXBeginGPUEventOnContext(context, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#endif
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXBeginEventOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        eventDestination = destination++;
+
+        PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIX_EVENT_METADATA_ON_CONTEXT |
+            PIXEncodeStringIsAnsi<STR>() |
+            PIXEncodeIndexColor(color);
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXBeginEventOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit == nullptr)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        if (destination < limit)
+        {
+            limit += PIXEventsSafeFastCopySpaceQwords;
+            UINT64 time = PIXGetTimestampCounter();
+            eventDestination = destination++;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = PIXEventsBlockEndMarker;
+
+            eventSize = PIXGetEventSize(destination, threadInfo->destination);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIXEncodeIndexColor(color);
+            *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+            threadInfo->destination = destination;
+        }
+        else
+        {
+            PIXBeginEventOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...);
+        }
+    }
+
+    template<typename CONTEXT, typename STR, typename... ARGS>
+    void PIXBeginEvent(CONTEXT* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = nullptr;
+        UINT8 eventSize = 0u;
+
+#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS
+        PIXBeginEventOnContextCpu(destination, eventSize, context, color, formatString, args...);
+#endif
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+        if (destination != nullptr)
+        {
+            PIXInsertTimingMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast<void*>(destination), eventSize * sizeof(UINT64));
+        }
+        else
+#endif
+        {
+            UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords];
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+            destination = buffer;
+            UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+            UINT64* eventDestination = destination++;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = 0ull;
+
+            eventSize = static_cast<const UINT8>(destination - buffer);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIXEncodeIndexColor(color);
+            *eventDestination = PIXEncodeEventInfo(0, PIXEvent_BeginEvent, eventSize, eventMetadata);
+
+            PIXInsertGPUMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#else
+            destination = PixEventsLegacy::EncodeBeginEventForContext(buffer, color, formatString, args...);
+            PIXBeginGPUEventOnContext(context, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#endif
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXSetMarkerOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        eventDestination = destination++;
+        *destination++ = color;
+
+        PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIX_EVENT_METADATA_ON_CONTEXT |
+            PIXEncodeStringIsAnsi<STR>() |
+            PIX_EVENT_METADATA_HAS_COLOR;
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXSetMarkerOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit == nullptr)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        if (destination < limit)
+        {
+            limit += PIXEventsSafeFastCopySpaceQwords;
+            UINT64 time = PIXGetTimestampCounter();
+            eventDestination = destination++;
+            *destination++ = color;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = PIXEventsBlockEndMarker;
+
+            eventSize = PIXGetEventSize(destination, threadInfo->destination);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIX_EVENT_METADATA_HAS_COLOR;
+            *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+            threadInfo->destination = destination;
+        }
+        else
+        {
+            PIXSetMarkerOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...);
+        }
+    }
+
+    template<typename CONTEXT, typename STR, typename... ARGS>
+    void PIXSetMarker(CONTEXT* context, UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = nullptr;
+        UINT8 eventSize = 0u;
+
+#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS
+        PIXSetMarkerOnContextCpu(destination, eventSize, context, color, formatString, args...);
+#endif
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+        if (destination != nullptr)
+        {
+            PIXInsertTimingMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast<void*>(destination), eventSize * sizeof(UINT64));
+        }
+        else
+#endif
+        {
+            UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords];
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+            destination = buffer;
+            UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+            UINT64* eventDestination = destination++;
+            *destination++ = color;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = 0ull;
+
+            eventSize = static_cast<const UINT8>(destination - buffer);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIX_EVENT_METADATA_HAS_COLOR;
+            *eventDestination = PIXEncodeEventInfo(0, PIXEvent_SetMarker, eventSize, eventMetadata);
+            PIXInsertGPUMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#else
+            destination = PixEventsLegacy::EncodeSetMarkerForContext(buffer, color, formatString, args...);
+            PIXSetGPUMarkerOnContext(context, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#endif
+        }
+    }
+
+    template<typename STR, typename... ARGS>
+    __declspec(noinline) void PIXSetMarkerOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, false);
+        if (!time)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        eventDestination = destination++;
+
+        PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+        *destination = PIXEventsBlockEndMarker;
+
+        eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata =
+            PIX_EVENT_METADATA_ON_CONTEXT |
+            PIXEncodeStringIsAnsi<STR>() |
+            PIXEncodeIndexColor(color);
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+    }
+
+    template<typename STR, typename... ARGS>
+    void PIXSetMarkerOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit == nullptr)
+        {
+            eventDestination = nullptr;
+            return;
+        }
+
+        UINT64* destination = threadInfo->destination;
+        if (destination < limit)
+        {
+            limit += PIXEventsSafeFastCopySpaceQwords;
+            UINT64 time = PIXGetTimestampCounter();
+            eventDestination = destination++;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = PIXEventsBlockEndMarker;
+
+            eventSize = PIXGetEventSize(destination, threadInfo->destination);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIXEncodeIndexColor(color);
+            *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata);
+
+            threadInfo->destination = destination;
+        }
+        else
+        {
+            PIXSetMarkerOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...);
+        }
+    }
+
+    template<typename CONTEXT, typename STR, typename... ARGS>
+    void PIXSetMarker(CONTEXT* context, UINT8 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = nullptr;
+        UINT8 eventSize = 0u;
+
+#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS
+        PIXSetMarkerOnContextCpu(destination, eventSize, context, color, formatString, args...);
+#endif
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+        if (destination != nullptr)
+        {
+            PIXInsertTimingMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast<void*>(destination), eventSize * sizeof(UINT64));
+        }
+        else
+#endif
+        {
+            UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords];
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+            destination = buffer;
+            UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+            UINT64* eventDestination = destination++;
+
+            PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...);
+            *destination = 0ull;
+
+            eventSize = static_cast<const UINT8>(destination - buffer);
+            const UINT8 eventMetadata =
+                PIX_EVENT_METADATA_ON_CONTEXT |
+                PIXEncodeStringIsAnsi<STR>() |
+                PIXEncodeIndexColor(color);
+            *eventDestination = PIXEncodeEventInfo(0, PIXEvent_SetMarker, eventSize, eventMetadata);
+            PIXInsertGPUMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#else
+            destination = PixEventsLegacy::EncodeSetMarkerForContext(buffer, color, formatString, args...);
+            PIXSetGPUMarkerOnContext(context, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#endif
+        }
+    }
+
+    __declspec(noinline) inline void PIXEndEventAllocate(PIXEventsThreadInfo* threadInfo)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, true);
+        if (!time)
+            return;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+            return;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        const UINT8 eventSize = 1;
+        const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE;
+        *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata);
+        *destination = PIXEventsBlockEndMarker;
+
+        threadInfo->destination = destination;
+    }
+
+    inline void PIXEndEvent()
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                const UINT8 eventSize = 1;
+                const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE;
+                *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata);
+                *destination = PIXEventsBlockEndMarker;
+
+                threadInfo->destination = destination;
+            }
+            else
+            {
+                PIXEndEventAllocate(threadInfo);
+            }
+        }
+    }
+
+    __declspec(noinline) inline UINT64* PIXEndEventOnContextCpuAllocate(PIXEventsThreadInfo* threadInfo, void* context)
+    {
+        UINT64 time = PIXEventsReplaceBlock(threadInfo, true);
+        if (!time)
+            return nullptr;
+
+        UINT64* destination = threadInfo->destination;
+        UINT64* limit = threadInfo->biasedLimit;
+
+        if (destination >= limit)
+            return nullptr;
+
+        limit += PIXEventsSafeFastCopySpaceQwords;
+        UINT64* eventDestination = destination++;
+#ifdef PIX_XBOX
+        UNREFERENCED_PARAMETER(context);
+#else
+        PIXCopyEventArgument(destination, limit, context);
+#endif
+        * destination = PIXEventsBlockEndMarker;
+
+        const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+        const UINT8 eventMetadata = PIX_EVENT_METADATA_ON_CONTEXT;
+        *eventDestination = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata);
+
+        threadInfo->destination = destination;
+
+        return eventDestination;
+    }
+
+    inline UINT64* PIXEndEventOnContextCpu(void* context)
+    {
+        PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo();
+        UINT64* limit = threadInfo->biasedLimit;
+        if (limit != nullptr)
+        {
+            UINT64* destination = threadInfo->destination;
+            if (destination < limit)
+            {
+                limit += PIXEventsSafeFastCopySpaceQwords;
+                UINT64 time = PIXGetTimestampCounter();
+                UINT64* eventDestination = destination++;
+#ifndef PIX_XBOX
+                PIXCopyEventArgument(destination, limit, context);
+#endif
+                * destination = PIXEventsBlockEndMarker;
+
+                const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination);
+                const UINT8 eventMetadata = PIX_EVENT_METADATA_ON_CONTEXT;
+                *eventDestination = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata);
+
+                threadInfo->destination = destination;
+
+                return eventDestination;
+            }
+            else
+            {
+                return PIXEndEventOnContextCpuAllocate(threadInfo, context);
+            }
+        }
+
+        return nullptr;
+    }
+
+    template<typename CONTEXT>
+    void PIXEndEvent(CONTEXT* context)
+    {
+        UINT64* destination = nullptr;
+#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS
+        destination = PIXEndEventOnContextCpu(context);
+#endif
+
+#ifdef PIX_USE_GPU_MARKERS_V2
+        if (destination != nullptr)
+        {
+            PIXInsertTimingMarkerOnContextForEndEvent(context, PIXEvent_EndEvent);
+        }
+        else
+#endif
+        {
+#ifdef PIX_USE_GPU_MARKERS_V2
+            UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords];
+            destination = buffer;
+
+            UINT64* eventDestination = destination++;
+
+            const UINT8 eventSize = static_cast<const UINT8>(destination - buffer);
+            const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE;
+            *eventDestination = PIXEncodeEventInfo(0, PIXEvent_EndEvent, eventSize, eventMetadata);
+            PIXInsertGPUMarkerOnContextForEndEvent(context, PIXEvent_EndEvent, static_cast<void*>(buffer), static_cast<UINT>(reinterpret_cast<BYTE*>(destination) - reinterpret_cast<BYTE*>(buffer)));
+#else
+            PIXEndGPUEventOnContext(context);
+#endif
+        }
+    }
+}
+
+#if defined(USE_PIX)
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXBeginEvent(UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(color, formatString, args...);
+}
+
+template<typename... ARGS>
+void PIXSetMarker(UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginEvent(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetMarker(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+inline void PIXEndEvent()
+{
+    PIXEventsDetail::PIXEndEvent();
+}
+
+template<typename CONTEXT>
+void PIXEndEvent(CONTEXT* context)
+{
+    PIXEventsDetail::PIXEndEvent(context);
+}
+
+#else // USE_PIX_RETAIL
+
+inline void PIXBeginEvent(UINT64, _In_ PCSTR, ...) {}
+inline void PIXBeginEvent(UINT64, _In_ PCWSTR, ...) {}
+inline void PIXBeginEvent(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXBeginEvent(void*, UINT64, _In_ PCWSTR, ...) {}
+inline void PIXEndEvent() {}
+inline void PIXEndEvent(void*) {}
+inline void PIXSetMarker(UINT64, _In_ PCSTR, ...) {}
+inline void PIXSetMarker(UINT64, _In_ PCWSTR, ...) {}
+inline void PIXSetMarker(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXSetMarker(void*, UINT64, _In_ PCWSTR, ...) {}
+
+#endif // USE_PIX
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXBeginRetailEvent(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, static_cast<UINT64>(color), formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT, typename... ARGS>
+void PIXSetRetailMarker(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+{
+    PIXEventsDetail::PIXSetMarker(context, color, formatString, args...);
+}
+
+template<typename CONTEXT>
+void PIXEndRetailEvent(CONTEXT* context)
+{
+    PIXEventsDetail::PIXEndEvent(context);
+}
+
+template<typename CONTEXT>
+class PIXScopedEventObject
+{
+    CONTEXT* m_context;
+
+public:
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginEvent(m_context, color, formatString, args...);
+    }
+
+    ~PIXScopedEventObject()
+    {
+        PIXEndEvent(m_context);
+    }
+};
+
+template<typename CONTEXT>
+class PIXScopedRetailEventObject
+{
+    CONTEXT* m_context;
+
+public:
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedRetailEventObject(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args)
+        : m_context(context)
+    {
+        PIXBeginRetailEvent(m_context, color, formatString, args...);
+    }
+
+    ~PIXScopedRetailEventObject()
+    {
+        PIXEndRetailEvent(m_context);
+    }
+};
+
+template<>
+class PIXScopedEventObject<void>
+{
+public:
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT64 color, PCWSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT64 color, PCSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT32 color, PCWSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT32 color, PCSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(INT32 color, PCWSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(INT32 color, PCSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(DWORD color, PCWSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(DWORD color, PCSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT8 color, PCWSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    template<typename... ARGS>
+    PIXScopedEventObject(UINT8 color, PCSTR formatString, ARGS... args)
+    {
+        PIXBeginEvent(color, formatString, args...);
+    }
+
+    ~PIXScopedEventObject()
+    {
+        PIXEndEvent();
+    }
+};
+
+#define PIXConcatenate(a, b) a ## b
+#define PIXGetScopedEventVariableName(a, b) PIXConcatenate(a, b)
+#define PIXScopedEvent(context, ...) PIXScopedEventObject<PIXInferScopedEventType<decltype(context)>::Type> PIXGetScopedEventVariableName(pixEvent, __LINE__)(context, __VA_ARGS__)
+
+#ifdef PIX3__DEFINED_CONSTEXPR
+#undef constexpr
+#undef PIX3__DEFINED_CONSTEXPR
+#endif
+
+#endif // _PIXEvents_H__
+
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h
new file mode 100644
index 0000000..ff26230
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h
@@ -0,0 +1,610 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Don't include this file directly - use pix3.h
+
+#pragma once
+
+#ifndef _PIXEventsCommon_H_
+#define _PIXEventsCommon_H_
+
+//
+// The PIXBeginEvent and PIXSetMarker functions have an optimized path for
+// copying strings that work by copying 128-bit or 64-bits at a time. In some
+// circumstances this may result in PIX logging the remaining memory after the
+// null terminator.
+//
+// By default this optimization is enabled unless Address Sanitizer is enabled,
+// since this optimization can trigger a global-buffer-overflow when copying
+// string literals.
+//
+// The PIX_ENABLE_BLOCK_ARGUMENT_COPY controls whether or not this optimization
+// is enabled. Applications may also explicitly set this macro to 0 to disable
+// the optimization if necessary.
+//
+
+// Check for Address Sanitizer on either Clang or MSVC
+
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define PIX_ASAN_ENABLED
+#endif
+#elif defined(__SANITIZE_ADDRESS__)
+#define PIX_ASAN_ENABLED
+#endif
+
+#if defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY)
+// Previously set values override everything
+# define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 0
+#elif defined(PIX_ASAN_ENABLED)
+// Disable block argument copy when address sanitizer is enabled
+#define PIX_ENABLE_BLOCK_ARGUMENT_COPY 0
+#define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1
+#endif
+
+#if !defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY)
+// Default to enabled.
+#define PIX_ENABLE_BLOCK_ARGUMENT_COPY 1
+#define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1
+#endif
+
+struct PIXEventsBlockInfo;
+
+struct PIXEventsThreadInfo
+{
+    PIXEventsBlockInfo* block;
+    UINT64* biasedLimit;
+    UINT64* destination;
+};
+
+extern "C" UINT64 WINAPI PIXEventsReplaceBlock(PIXEventsThreadInfo * threadInfo, bool getEarliestTime) noexcept;
+
+#define PIX_EVENT_METADATA_NONE                     0x0
+#define PIX_EVENT_METADATA_ON_CONTEXT               0x1
+#define PIX_EVENT_METADATA_STRING_IS_ANSI           0x2
+#define PIX_EVENT_METADATA_HAS_COLOR                0xF0
+
+#ifndef PIX_GAMING_XBOX
+#include "PIXEventsLegacy.h"
+#endif
+
+enum PIXEventType : UINT8
+{
+    PIXEvent_EndEvent       = 0x00,
+    PIXEvent_BeginEvent     = 0x01,
+    PIXEvent_SetMarker      = 0x02,
+};
+
+static const UINT64 PIXEventsReservedRecordSpaceQwords = 64;
+//this is used to make sure SSE string copy always will end 16-byte write in the current block
+//this way only a check if destination < limit can be performed, instead of destination < limit - 1
+//since both these are UINT64* and SSE writes in 16 byte chunks, 8 bytes are kept in reserve
+//so even if SSE overwrites 8-15 extra bytes, those will still belong to the correct block
+//on next iteration check destination will be greater than limit
+//this is used as well for fixed size UMD events and PIXEndEvent since these require less space
+//than other variable length user events and do not need big reserved space
+static const UINT64 PIXEventsReservedTailSpaceQwords = 2;
+static const UINT64 PIXEventsSafeFastCopySpaceQwords = PIXEventsReservedRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+static const UINT64 PIXEventsGraphicsRecordSpaceQwords = 64;
+
+//Bits 7-19 (13 bits)
+static const UINT64 PIXEventsBlockEndMarker     = 0x00000000000FFF80;
+
+
+// V2 events
+
+// Bits 00..06 (7 bits) - Size in QWORDS
+static const UINT64 PIXEventsSizeWriteMask      = 0x000000000000007F;
+static const UINT64 PIXEventsSizeBitShift       = 0;
+static const UINT64 PIXEventsSizeReadMask       = PIXEventsSizeWriteMask << PIXEventsSizeBitShift;
+static const UINT64 PIXEventsSizeMax            = (1ull << 7) - 1ull;
+
+// Bits 07..11 (5 bits) - Event Type
+static const UINT64 PIXEventsTypeWriteMask      = 0x000000000000001F;
+static const UINT64 PIXEventsTypeBitShift       = 7;
+static const UINT64 PIXEventsTypeReadMask       = PIXEventsTypeWriteMask << PIXEventsTypeBitShift;
+
+// Bits 12..19 (8 bits) - Event Specific Metadata
+static const UINT64 PIXEventsMetadataWriteMask  = 0x00000000000000FF;
+static const UINT64 PIXEventsMetadataBitShift   = 12;
+static const UINT64 PIXEventsMetadataReadMask   = PIXEventsMetadataWriteMask << PIXEventsMetadataBitShift;
+
+// Buts 20..63 (44 bits) - Timestamp
+static const UINT64 PIXEventsTimestampWriteMask = 0x00000FFFFFFFFFFF;
+static const UINT64 PIXEventsTimestampBitShift  = 20;
+static const UINT64 PIXEventsTimestampReadMask  = PIXEventsTimestampWriteMask << PIXEventsTimestampBitShift;
+
+inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType, UINT8 eventSize, UINT8 eventMetadata)
+{
+    return
+        ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) |
+        (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift) |
+        (((UINT64)eventMetadata & PIXEventsMetadataWriteMask) << PIXEventsMetadataBitShift) |
+        (((UINT64)eventSize & PIXEventsSizeWriteMask) << PIXEventsSizeBitShift);
+}
+
+inline UINT8 PIXEncodeIndexColor(UINT8 color)
+{
+    // There are 8 index colors, indexed 0 (default) to 7
+    return (color & 0x7) << 4;
+}
+
+//Bits 60-63 (4)
+static const UINT64 PIXEventsStringAlignmentWriteMask     = 0x000000000000000F;
+static const UINT64 PIXEventsStringAlignmentReadMask      = 0xF000000000000000;
+static const UINT64 PIXEventsStringAlignmentBitShift      = 60;
+
+//Bits 55-59 (5)
+static const UINT64 PIXEventsStringCopyChunkSizeWriteMask = 0x000000000000001F;
+static const UINT64 PIXEventsStringCopyChunkSizeReadMask  = 0x0F80000000000000;
+static const UINT64 PIXEventsStringCopyChunkSizeBitShift  = 55;
+
+//Bit 54
+static const UINT64 PIXEventsStringIsANSIWriteMask        = 0x0000000000000001;
+static const UINT64 PIXEventsStringIsANSIReadMask         = 0x0040000000000000;
+static const UINT64 PIXEventsStringIsANSIBitShift         = 54;
+
+//Bit 53
+static const UINT64 PIXEventsStringIsShortcutWriteMask    = 0x0000000000000001;
+static const UINT64 PIXEventsStringIsShortcutReadMask     = 0x0020000000000000;
+static const UINT64 PIXEventsStringIsShortcutBitShift     = 53;
+
+inline void PIXEncodeStringInfo(UINT64*& destination, BOOL isANSI)
+{
+    const UINT64 encodedStringInfo = 
+        ((sizeof(UINT64) & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) |
+        (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift);
+
+    *destination++ = encodedStringInfo;
+}
+
+template<UINT alignment, class T>
+inline bool PIXIsPointerAligned(T* pointer)
+{
+    return !(((UINT64)pointer) & (alignment - 1));
+}
+
+// Generic template version slower because of the additional clear write
+template<class T>
+inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, T argument)
+{
+    if (destination < limit)
+    {
+        *destination = 0ull;
+        *((T*)destination) = argument;
+        ++destination;
+    }
+}
+
+// int32 specialization to avoid slower double memory writes
+template<>
+inline void PIXCopyEventArgument<INT32>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT32 argument)
+{
+    if (destination < limit)
+    {
+        *reinterpret_cast<INT64*>(destination) = static_cast<INT64>(argument);
+        ++destination;
+    }
+}
+
+// unsigned int32 specialization to avoid slower double memory writes
+template<>
+inline void PIXCopyEventArgument<UINT32>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT32 argument)
+{
+    if (destination < limit)
+    {
+        *destination = static_cast<UINT64>(argument);
+        ++destination;
+    }
+}
+
+// int64 specialization to avoid slower double memory writes
+template<>
+inline void PIXCopyEventArgument<INT64>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT64 argument)
+{
+    if (destination < limit)
+    {
+        *reinterpret_cast<INT64*>(destination) = argument;
+        ++destination;
+    }
+}
+
+// unsigned int64 specialization to avoid slower double memory writes
+template<>
+inline void PIXCopyEventArgument<UINT64>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT64 argument)
+{
+    if (destination < limit)
+    {
+        *destination = argument;
+        ++destination;
+    }
+}
+
+//floats must be cast to double during writing the data to be properly printed later when reading the data
+//this is needed because when float is passed to varargs function it's cast to double
+template<>
+inline void PIXCopyEventArgument<float>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, float argument)
+{
+    if (destination < limit)
+    {
+        *reinterpret_cast<double*>(destination) = static_cast<double>(argument);
+        ++destination;
+    }
+}
+
+//char has to be cast to a longer signed integer type
+//this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier
+template<>
+inline void PIXCopyEventArgument<char>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, char argument)
+{
+    if (destination < limit)
+    {
+        *reinterpret_cast<INT64*>(destination) = static_cast<INT64>(argument);
+        ++destination;
+    }
+}
+
+//UINT8 has to be cast to a longer unsigned integer type
+//this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier
+template<>
+inline void PIXCopyEventArgument<UINT8>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT8 argument)
+{
+    if (destination < limit)
+    {
+        *destination = static_cast<UINT64>(argument);
+        ++destination;
+    }
+}
+
+//bool has to be cast to an integer since it's not explicitly supported by string format routines
+//there's no format specifier for bool type, but it should work with integer format specifiers
+template<>
+inline void PIXCopyEventArgument<bool>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, bool argument)
+{
+    if (destination < limit)
+    {
+        *destination = static_cast<UINT64>(argument);
+        ++destination;
+    }
+}
+
+inline void PIXCopyEventStringArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    while (destination < limit)
+    {
+        UINT64 c = static_cast<UINT8>(argument[0]);
+        if (!c)
+        {
+            *destination++ = 0;
+            return;
+        }
+        UINT64 x = c;
+        c = static_cast<UINT8>(argument[1]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 8;
+        c = static_cast<UINT8>(argument[2]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 16;
+        c = static_cast<UINT8>(argument[3]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 24;
+        c = static_cast<UINT8>(argument[4]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 32;
+        c = static_cast<UINT8>(argument[5]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 40;
+        c = static_cast<UINT8>(argument[6]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 48;
+        c = static_cast<UINT8>(argument[7]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 56;
+        *destination++ = x;
+        argument += 8;
+    }
+}
+
+template<bool>
+inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    PIXEncodeStringInfo(destination, TRUE);
+    PIXCopyEventStringArgumentSlow(destination, limit, argument);
+}
+
+template<>
+inline void PIXCopyEventArgumentSlow<false>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    PIXCopyEventStringArgumentSlow(destination, limit, argument);
+}
+
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+
+inline void PIXCopyEventStringArgumentFast(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    constexpr UINT64 mask1 = 0x0101010101010101ULL;
+    constexpr UINT64 mask2 = 0x8080808080808080ULL;
+    UINT64* source = (UINT64*)argument;
+
+    while (destination < limit)
+    {
+        UINT64 qword = *source++;
+        *destination++ = qword;
+
+        //check if any of the characters is a terminating zero
+        UINT64 isTerminated = (qword - mask1) & (~qword & mask2);
+
+        if (isTerminated)
+        {
+            break;
+        }
+    }
+}
+#endif
+
+template<>
+inline void PIXCopyEventArgument<PCSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    if (destination < limit)
+    {
+        if (argument != nullptr)
+        {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+            if (PIXIsPointerAligned<8>(argument))
+            {
+                PIXEncodeStringInfo(destination, TRUE);
+                PIXCopyEventStringArgumentFast(destination, limit, argument);
+            }
+            else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+            {
+                PIXCopyEventArgumentSlow<true>(destination, limit, argument);
+            }
+        }
+        else
+        {
+            *destination++ = 0ull;
+        }
+    }
+}
+
+inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+{
+    if (argument != nullptr)
+    {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        if (PIXIsPointerAligned<8>(argument))
+        {
+            PIXCopyEventStringArgumentFast(destination, limit, argument);
+        }
+        else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        {
+            PIXCopyEventArgumentSlow<false>(destination, limit, argument);
+        }
+    }
+    else
+    {
+        *destination++ = 0ull;
+    }
+}
+
+template<>
+inline void PIXCopyEventArgument<PSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument)
+{
+    PIXCopyEventArgument(destination, limit, (PCSTR)argument);
+}
+
+inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument)
+{
+    PIXCopyStringArgument(destination, limit, (PCSTR)argument);
+}
+
+inline void PIXCopyEventStringArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    while (destination < limit)
+    {
+        UINT64 c = static_cast<UINT16>(argument[0]);
+        if (!c)
+        {
+            *destination++ = 0;
+            return;
+        }
+        UINT64 x = c;
+        c = static_cast<UINT16>(argument[1]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 16;
+        c = static_cast<UINT16>(argument[2]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 32;
+        c = static_cast<UINT16>(argument[3]);
+        if (!c)
+        {
+            *destination++ = x;
+            return;
+        }
+        x |= c << 48;
+        *destination++ = x;
+        argument += 4;
+    }
+}
+
+template<bool>
+inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    PIXEncodeStringInfo(destination, FALSE);
+    PIXCopyEventStringArgumentSlow(destination, limit, argument);
+}
+
+template<>
+inline void PIXCopyEventArgumentSlow<false>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    PIXCopyEventStringArgumentSlow(destination, limit, argument);
+}
+
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+inline void PIXCopyEventStringArgumentFast(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    UINT64* source = (UINT64*)argument;
+    while (destination < limit)
+    {
+        UINT64 qword = *source++;
+        *destination++ = qword;
+        //check if any of the characters is a terminating zero
+        //TODO: check if reversed condition is faster
+        if (!((qword & 0xFFFF000000000000) &&
+            (qword & 0xFFFF00000000) &&
+            (qword & 0xFFFF0000) &&
+            (qword & 0xFFFF)))
+        {
+            break;
+        }
+    }
+}
+#endif
+
+template<>
+inline void PIXCopyEventArgument<PCWSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    if (destination < limit)
+    {
+        if (argument != nullptr)
+        {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+            if (PIXIsPointerAligned<8>(argument))
+            {
+                PIXEncodeStringInfo(destination, FALSE);
+                PIXCopyEventStringArgumentFast(destination, limit, argument);
+            }
+            else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+            {
+                PIXCopyEventArgumentSlow<true>(destination, limit, argument);
+            }
+        }
+        else
+        {
+            *destination++ = 0ull;
+        }
+    }
+}
+
+inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+{
+    if (argument != nullptr)
+    {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        if (PIXIsPointerAligned<8>(argument))
+        {
+            PIXCopyEventStringArgumentFast(destination, limit, argument);
+        }
+        else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        {
+            PIXCopyEventArgumentSlow<false>(destination, limit, argument);
+        }
+    }
+    else
+    {
+        *destination++ = 0ull;
+    }
+}
+
+template<>
+inline void PIXCopyEventArgument<PWSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PWSTR argument)
+{
+    PIXCopyEventArgument(destination, limit, (PCWSTR)argument);
+};
+
+inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PWSTR argument)
+{
+    PIXCopyStringArgument(destination, limit, (PCWSTR)argument);
+};
+
+#if defined(__d3d12_x_h__) || defined(__d3d12_xs_h__) || defined(__d3d12_h__)
+
+inline void PIXSetGPUMarkerOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size)
+{
+    commandList->SetMarker(D3D12_EVENT_METADATA, data, size);
+}
+
+inline void PIXSetGPUMarkerOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size)
+{
+    commandQueue->SetMarker(D3D12_EVENT_METADATA, data, size);
+}
+
+inline void PIXBeginGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size)
+{
+    commandList->BeginEvent(D3D12_EVENT_METADATA, data, size);
+}
+
+inline void PIXBeginGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size)
+{
+    commandQueue->BeginEvent(D3D12_EVENT_METADATA, data, size);
+}
+
+inline void PIXEndGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList)
+{
+    commandList->EndEvent();
+}
+
+inline void PIXEndGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue)
+{
+    commandQueue->EndEvent();
+}
+
+#endif //__d3d12_h__
+
+template<class T> struct PIXInferScopedEventType { typedef T Type; };
+template<class T> struct PIXInferScopedEventType<const T> { typedef T Type; };
+template<class T> struct PIXInferScopedEventType<T*> { typedef T Type; };
+template<class T> struct PIXInferScopedEventType<T* const> { typedef T Type; };
+template<> struct PIXInferScopedEventType<UINT64> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const UINT64> { typedef void Type; };
+template<> struct PIXInferScopedEventType<INT64> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const INT64> { typedef void Type; };
+template<> struct PIXInferScopedEventType<UINT> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const UINT> { typedef void Type; };
+template<> struct PIXInferScopedEventType<INT> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const INT> { typedef void Type; };
+template<> struct PIXInferScopedEventType<UINT8> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const UINT8> { typedef void Type; };
+template<> struct PIXInferScopedEventType<INT8> { typedef void Type; };
+template<> struct PIXInferScopedEventType<const INT8> { typedef void Type; };
+
+#endif //_PIXEventsCommon_H_
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsLegacy.h b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsLegacy.h
new file mode 100644
index 0000000..b5b08be
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsLegacy.h
@@ -0,0 +1,565 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Don't include this file directly - use pix3.h
+// This file encodes PIX events in the legacy PIX event format.
+
+#ifndef _PIXEventsLegacy_H_
+#define _PIXEventsLegacy_H_
+
+#include <cstdint>
+
+#if defined(_M_X64) || defined(_M_IX86)
+#include <emmintrin.h>
+#endif
+
+namespace PixEventsLegacy
+{
+    enum PIXEventType
+    {
+        PIXEvent_EndEvent = 0x000,
+        PIXEvent_BeginEvent_VarArgs = 0x001,
+        PIXEvent_BeginEvent_NoArgs = 0x002,
+        PIXEvent_SetMarker_VarArgs = 0x007,
+        PIXEvent_SetMarker_NoArgs = 0x008,
+
+        PIXEvent_EndEvent_OnContext = 0x010,
+        PIXEvent_BeginEvent_OnContext_VarArgs = 0x011,
+        PIXEvent_BeginEvent_OnContext_NoArgs = 0x012,
+        PIXEvent_SetMarker_OnContext_VarArgs = 0x017,
+        PIXEvent_SetMarker_OnContext_NoArgs = 0x018,
+    };
+
+    static const UINT64 PIXEventsReservedRecordSpaceQwords = 64;
+    static const UINT64 PIXEventsReservedTailSpaceQwords = 2;
+    static const UINT64 PIXEventsSafeFastCopySpaceQwords = PIXEventsReservedRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+    static const UINT64 PIXEventsGraphicsRecordSpaceQwords = 64;
+
+    //Bits 7-19 (13 bits)
+    static const UINT64 PIXEventsBlockEndMarker = 0x00000000000FFF80;
+
+    //Bits 10-19 (10 bits)
+    static const UINT64 PIXEventsTypeReadMask = 0x00000000000FFC00;
+    static const UINT64 PIXEventsTypeWriteMask = 0x00000000000003FF;
+    static const UINT64 PIXEventsTypeBitShift = 10;
+
+    //Bits 20-63 (44 bits)
+    static const UINT64 PIXEventsTimestampReadMask = 0xFFFFFFFFFFF00000;
+    static const UINT64 PIXEventsTimestampWriteMask = 0x00000FFFFFFFFFFF;
+    static const UINT64 PIXEventsTimestampBitShift = 20;
+
+    inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType)
+    {
+        return ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) |
+            (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift);
+    }
+
+    //Bits 60-63 (4)
+    static const UINT64 PIXEventsStringAlignmentWriteMask = 0x000000000000000F;
+    static const UINT64 PIXEventsStringAlignmentReadMask = 0xF000000000000000;
+    static const UINT64 PIXEventsStringAlignmentBitShift = 60;
+
+    //Bits 55-59 (5)
+    static const UINT64 PIXEventsStringCopyChunkSizeWriteMask = 0x000000000000001F;
+    static const UINT64 PIXEventsStringCopyChunkSizeReadMask = 0x0F80000000000000;
+    static const UINT64 PIXEventsStringCopyChunkSizeBitShift = 55;
+
+    //Bit 54
+    static const UINT64 PIXEventsStringIsANSIWriteMask = 0x0000000000000001;
+    static const UINT64 PIXEventsStringIsANSIReadMask = 0x0040000000000000;
+    static const UINT64 PIXEventsStringIsANSIBitShift = 54;
+
+    //Bit 53
+    static const UINT64 PIXEventsStringIsShortcutWriteMask = 0x0000000000000001;
+    static const UINT64 PIXEventsStringIsShortcutReadMask = 0x0020000000000000;
+    static const UINT64 PIXEventsStringIsShortcutBitShift = 53;
+
+    inline UINT64 PIXEncodeStringInfo(UINT64 alignment, UINT64 copyChunkSize, BOOL isANSI, BOOL isShortcut)
+    {
+        return ((alignment & PIXEventsStringAlignmentWriteMask) << PIXEventsStringAlignmentBitShift) |
+            ((copyChunkSize & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) |
+            (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift) |
+            (((UINT64)isShortcut & PIXEventsStringIsShortcutWriteMask) << PIXEventsStringIsShortcutBitShift);
+    }
+
+    template<UINT alignment, class T>
+    inline bool PIXIsPointerAligned(T* pointer)
+    {
+        return !(((UINT64)pointer) & (alignment - 1));
+    }
+
+    // Generic template version slower because of the additional clear write
+    template<class T>
+    inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, T argument)
+    {
+        if (destination < limit)
+        {
+            *destination = 0ull;
+            *((T*)destination) = argument;
+            ++destination;
+        }
+    }
+
+    // int32 specialization to avoid slower double memory writes
+    template<>
+    inline void PIXCopyEventArgument<INT32>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT32 argument)
+    {
+        if (destination < limit)
+        {
+            *reinterpret_cast<INT64*>(destination) = static_cast<INT64>(argument);
+            ++destination;
+        }
+    }
+
+    // unsigned int32 specialization to avoid slower double memory writes
+    template<>
+    inline void PIXCopyEventArgument<UINT32>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT32 argument)
+    {
+        if (destination < limit)
+        {
+            *destination = static_cast<UINT64>(argument);
+            ++destination;
+        }
+    }
+
+    // int64 specialization to avoid slower double memory writes
+    template<>
+    inline void PIXCopyEventArgument<INT64>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT64 argument)
+    {
+        if (destination < limit)
+        {
+            *reinterpret_cast<INT64*>(destination) = argument;
+            ++destination;
+        }
+    }
+
+    // unsigned int64 specialization to avoid slower double memory writes
+    template<>
+    inline void PIXCopyEventArgument<UINT64>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT64 argument)
+    {
+        if (destination < limit)
+        {
+            *destination = argument;
+            ++destination;
+        }
+    }
+
+    //floats must be cast to double during writing the data to be properly printed later when reading the data
+    //this is needed because when float is passed to varargs function it's cast to double
+    template<>
+    inline void PIXCopyEventArgument<float>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, float argument)
+    {
+        if (destination < limit)
+        {
+            *reinterpret_cast<double*>(destination) = static_cast<double>(argument);
+            ++destination;
+        }
+    }
+
+    //char has to be cast to a longer signed integer type
+    //this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier
+    template<>
+    inline void PIXCopyEventArgument<char>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, char argument)
+    {
+        if (destination < limit)
+        {
+            *reinterpret_cast<INT64*>(destination) = static_cast<INT64>(argument);
+            ++destination;
+        }
+    }
+
+    //unsigned char has to be cast to a longer unsigned integer type
+    //this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier
+    template<>
+    inline void PIXCopyEventArgument<unsigned char>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, unsigned char argument)
+    {
+        if (destination < limit)
+        {
+            *destination = static_cast<UINT64>(argument);
+            ++destination;
+        }
+    }
+
+    //bool has to be cast to an integer since it's not explicitly supported by string format routines
+    //there's no format specifier for bool type, but it should work with integer format specifiers
+    template<>
+    inline void PIXCopyEventArgument<bool>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, bool argument)
+    {
+        if (destination < limit)
+        {
+            *destination = static_cast<UINT64>(argument);
+            ++destination;
+        }
+    }
+
+    inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+    {
+        *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE);
+        while (destination < limit)
+        {
+            UINT64 c = static_cast<uint8_t>(argument[0]);
+            if (!c)
+            {
+                *destination++ = 0;
+                return;
+            }
+            UINT64 x = c;
+            c = static_cast<uint8_t>(argument[1]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 8;
+            c = static_cast<uint8_t>(argument[2]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 16;
+            c = static_cast<uint8_t>(argument[3]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 24;
+            c = static_cast<uint8_t>(argument[4]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 32;
+            c = static_cast<uint8_t>(argument[5]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 40;
+            c = static_cast<uint8_t>(argument[6]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 48;
+            c = static_cast<uint8_t>(argument[7]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 56;
+            *destination++ = x;
+            argument += 8;
+        }
+    }
+
+    inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+    {
+#if PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        if (PIXIsPointerAligned<8>(argument))
+        {
+            *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE);
+            UINT64* source = (UINT64*)argument;
+            while (destination < limit)
+            {
+                UINT64 qword = *source++;
+                *destination++ = qword;
+                //check if any of the characters is a terminating zero
+                if (!((qword & 0xFF00000000000000) &&
+                    (qword & 0xFF000000000000) &&
+                    (qword & 0xFF0000000000) &&
+                    (qword & 0xFF00000000) &&
+                    (qword & 0xFF000000) &&
+                    (qword & 0xFF0000) &&
+                    (qword & 0xFF00) &&
+                    (qword & 0xFF)))
+                {
+                    break;
+                }
+            }
+        }
+        else
+#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        {
+            PIXCopyEventArgumentSlowest(destination, limit, argument);
+        }
+    }
+
+    template<>
+    inline void PIXCopyEventArgument<PCSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument)
+    {
+        if (destination < limit)
+        {
+            if (argument != nullptr)
+            {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+                if (PIXIsPointerAligned<16>(argument))
+                {
+                    *destination++ = PIXEncodeStringInfo(0, 16, TRUE, FALSE);
+                    __m128i zero = _mm_setzero_si128();
+                    if (PIXIsPointerAligned<16>(destination))
+                    {
+                        while (destination < limit)
+                        {
+                            __m128i mem = _mm_load_si128((__m128i*)argument);
+                            _mm_store_si128((__m128i*)destination, mem);
+                            //check if any of the characters is a terminating zero
+                            __m128i res = _mm_cmpeq_epi8(mem, zero);
+                            destination += 2;
+                            if (_mm_movemask_epi8(res))
+                                break;
+                            argument += 16;
+                        }
+                    }
+                    else
+                    {
+                        while (destination < limit)
+                        {
+                            __m128i mem = _mm_load_si128((__m128i*)argument);
+                            _mm_storeu_si128((__m128i*)destination, mem);
+                            //check if any of the characters is a terminating zero
+                            __m128i res = _mm_cmpeq_epi8(mem, zero);
+                            destination += 2;
+                            if (_mm_movemask_epi8(res))
+                                break;
+                            argument += 16;
+                        }
+                    }
+                }
+                else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+                {
+                    PIXCopyEventArgumentSlow(destination, limit, argument);
+                }
+            }
+            else
+            {
+                *destination++ = 0ull;
+            }
+        }
+    }
+
+    template<>
+    inline void PIXCopyEventArgument<PSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument)
+    {
+        PIXCopyEventArgument(destination, limit, (PCSTR)argument);
+    }
+
+    inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+    {
+        *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE);
+        while (destination < limit)
+        {
+            UINT64 c = static_cast<uint16_t>(argument[0]);
+            if (!c)
+            {
+                *destination++ = 0;
+                return;
+            }
+            UINT64 x = c;
+            c = static_cast<uint16_t>(argument[1]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 16;
+            c = static_cast<uint16_t>(argument[2]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 32;
+            c = static_cast<uint16_t>(argument[3]);
+            if (!c)
+            {
+                *destination++ = x;
+                return;
+            }
+            x |= c << 48;
+            *destination++ = x;
+            argument += 4;
+        }
+    }
+
+    inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+    {
+#if PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        if (PIXIsPointerAligned<8>(argument))
+        {
+            *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE);
+            UINT64* source = (UINT64*)argument;
+            while (destination < limit)
+            {
+                UINT64 qword = *source++;
+                *destination++ = qword;
+                //check if any of the characters is a terminating zero
+                //TODO: check if reversed condition is faster
+                if (!((qword & 0xFFFF000000000000) &&
+                    (qword & 0xFFFF00000000) &&
+                    (qword & 0xFFFF0000) &&
+                    (qword & 0xFFFF)))
+                {
+                    break;
+                }
+            }
+        }
+        else
+#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY
+        {
+            PIXCopyEventArgumentSlowest(destination, limit, argument);
+        }
+    }
+
+    template<>
+    inline void PIXCopyEventArgument<PCWSTR>(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument)
+    {
+        if (destination < limit)
+        {
+            if (argument != nullptr)
+            {
+#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+                if (PIXIsPointerAligned<16>(argument))
+                {
+                    *destination++ = PIXEncodeStringInfo(0, 16, FALSE, FALSE);
+                    __m128i zero = _mm_setzero_si128();
+                    if (PIXIsPointerAligned<16>(destination))
+                    {
+                        while (destination < limit)
+                        {
+                            __m128i mem = _mm_load_si128((__m128i*)argument);
+                            _mm_store_si128((__m128i*)destination, mem);
+                            //check if any of the characters is a terminating zero
+                            __m128i res = _mm_cmpeq_epi16(mem, zero);
+                            destination += 2;
+                            if (_mm_movemask_epi8(res))
+                                break;
+                            argument += 8;
+                        }
+                    }
+                    else
+                    {
+                        while (destination < limit)
+                        {
+                            __m128i mem = _mm_load_si128((__m128i*)argument);
+                            _mm_storeu_si128((__m128i*)destination, mem);
+                            //check if any of the characters is a terminating zero
+                            __m128i res = _mm_cmpeq_epi16(mem, zero);
+                            destination += 2;
+                            if (_mm_movemask_epi8(res))
+                                break;
+                            argument += 8;
+                        }
+                    }
+                }
+                else
+#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY
+                {
+                    PIXCopyEventArgumentSlow(destination, limit, argument);
+                }
+            }
+            else
+            {
+                *destination++ = 0ull;
+            }
+        }
+    }
+
+    inline void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit)
+    {
+        // nothing
+        UNREFERENCED_PARAMETER(destination);
+        UNREFERENCED_PARAMETER(limit);
+    }
+
+    template<typename ARG, typename... ARGS>
+    void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args)
+    {
+        PIXCopyEventArgument(destination, limit, arg);
+        PIXCopyEventArguments(destination, limit, args...);
+    }
+
+    template<typename... ARGS>
+    struct PIXEventTypeInferer
+    {
+        static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_VarArgs; }
+        static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_VarArgs; }
+        static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; }
+        static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; }
+        static constexpr PIXEventType End() { return PIXEvent_EndEvent; }
+
+        // Xbox and Windows store different types of events for context events.
+        // On Xbox these include a context argument, while on Windows they do
+        // not. It is important not to change the event types used on the
+        // Windows version as there are OS components (eg debug layer & DRED)
+        // that decode event structs.
+#ifdef PIX_XBOX
+        static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; }
+        static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; }
+        static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent_OnContext; }
+#else
+        static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_VarArgs; }
+        static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_VarArgs; }
+        static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent; }
+#endif
+    };
+
+    template<>
+    struct PIXEventTypeInferer<>
+    {
+        static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_NoArgs; }
+        static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_NoArgs; }
+        static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; }
+        static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; }
+        static constexpr PIXEventType End() { return PIXEvent_EndEvent; }
+
+#ifdef PIX_XBOX
+        static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; }
+        static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; }
+        static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent_OnContext; }
+#else
+        static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_NoArgs; }
+        static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_NoArgs; }
+        static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent; }
+#endif
+    };
+
+
+    template<size_t size, typename STR, typename... ARGS>
+    UINT64* EncodeBeginEventForContext(UINT64 (&buffer)[size], UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = buffer;
+        UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+        *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer<ARGS...>::GpuBeginOnContext());
+        *destination++ = color;
+
+        PIXCopyEventArguments(destination, limit, formatString, args...);
+        *destination = 0ull;
+
+        return destination;
+    }
+
+    template<size_t size, typename STR, typename... ARGS>
+    UINT64* EncodeSetMarkerForContext(UINT64 (&buffer)[size], UINT64 color, STR formatString, ARGS... args)
+    {
+        UINT64* destination = buffer;
+        UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords;
+
+        *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer<ARGS...>::GpuSetMarkerOnContext());
+        *destination++ = color;
+
+        PIXCopyEventArguments(destination, limit, formatString, args...);
+        *destination = 0ull;
+
+        return destination;
+    }
+}
+
+#endif //_PIXEventsLegacy_H_
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h
new file mode 100644
index 0000000..b13e8bc
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h
@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifndef _PIX3_H_
+#define _PIX3_H_
+
+#include <sal.h>
+
+#ifndef __cplusplus
+#error "Only C++ files can include pix3.h. C is not supported."
+#endif
+
+#if !defined(USE_PIX_SUPPORTED_ARCHITECTURE)
+#if defined(_M_X64) || defined(USE_PIX_ON_ALL_ARCHITECTURES) || defined(_M_ARM64)
+#define USE_PIX_SUPPORTED_ARCHITECTURE
+#endif
+#endif
+
+#if !defined(USE_PIX)
+#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && (defined(_DEBUG) || DBG || defined(PROFILE) || defined(PROFILE_BUILD)) && !defined(_PREFAST_)
+#define USE_PIX
+#endif
+#endif
+
+#if defined(USE_PIX) && !defined(USE_PIX_SUPPORTED_ARCHITECTURE)
+#pragma message("Warning: Pix markers are only supported on AMD64 and ARM64")
+#endif
+
+
+// These flags are used by both PIXBeginCapture and PIXGetCaptureState
+#define PIX_CAPTURE_TIMING                  (1 << 0)
+#define PIX_CAPTURE_GPU                     (1 << 1)
+#define PIX_CAPTURE_FUNCTION_SUMMARY        (1 << 2)
+#define PIX_CAPTURE_FUNCTION_DETAILS        (1 << 3)
+#define PIX_CAPTURE_CALLGRAPH               (1 << 4)
+#define PIX_CAPTURE_INSTRUCTION_TRACE       (1 << 5)
+#define PIX_CAPTURE_SYSTEM_MONITOR_COUNTERS (1 << 6)
+#define PIX_CAPTURE_VIDEO                   (1 << 7)
+#define PIX_CAPTURE_AUDIO                   (1 << 8)
+#define PIX_CAPTURE_GPU_TRACE               (1 << 9)
+#define PIX_CAPTURE_RESERVED                (1 << 15)
+
+union PIXCaptureParameters
+{
+    enum PIXCaptureStorage
+    {
+        Memory = 0,
+        MemoryCircular = 1, // Xbox only
+        FileCircular = 2, // PC only
+    };
+
+    struct GpuCaptureParameters
+    {
+        PCWSTR FileName;
+    } GpuCaptureParameters;
+
+    struct TimingCaptureParameters
+    {
+        PCWSTR FileName;
+        UINT32 MaximumToolingMemorySizeMb;
+        PIXCaptureStorage CaptureStorage;
+
+        BOOL CaptureGpuTiming;
+
+        BOOL CaptureCallstacks;
+        BOOL CaptureCpuSamples;
+        UINT32 CpuSamplesPerSecond;
+
+        BOOL CaptureFileIO;
+
+        BOOL CaptureVirtualAllocEvents;
+        BOOL CaptureHeapAllocEvents;
+        BOOL CaptureXMemEvents; // Xbox only
+        BOOL CapturePixMemEvents;
+        BOOL CapturePageFaultEvents;
+        BOOL CaptureVideoFrames; // Xbox only
+    } TimingCaptureParameters;
+
+    struct GpuTraceParameters // Xbox Series and newer only
+    {
+        PWSTR FileName;
+        UINT32 MaximumToolingMemorySizeMb;
+
+        BOOL CaptureGpuOccupancy;
+
+    } GpuTraceParameters;
+};
+
+typedef PIXCaptureParameters* PPIXCaptureParameters;
+
+#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) || defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT)
+#include "pix3_xbox.h"
+#else
+#include "pix3_win.h"
+#endif
+
+#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) || defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT)
+#define PIX_XBOX
+#if defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT)
+#define PIX_GAMING_XBOX
+#endif
+#endif
+
+#if !defined(PIX_USE_GPU_MARKERS_V2)
+#ifdef PIX_GAMING_XBOX 
+#define PIX_USE_GPU_MARKERS_V2
+#endif
+#endif
+
+#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && (defined(USE_PIX) || defined(USE_PIX_RETAIL))
+
+#define PIX_EVENTS_ARE_TURNED_ON
+
+#include "PIXEventsCommon.h"
+#include "PIXEvents.h"
+
+#ifdef USE_PIX
+// Starts a programmatically controlled capture.
+// captureFlags uses the PIX_CAPTURE_* family of flags to specify the type of capture to take
+extern "C" HRESULT WINAPI PIXBeginCapture2(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters);
+inline HRESULT PIXBeginCapture(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters) { return PIXBeginCapture2(captureFlags, captureParameters); }
+
+// Stops a programmatically controlled capture
+//  If discard == TRUE, the captured data is discarded
+//  If discard == FALSE, the captured data is saved
+//  discard parameter is not supported on Windows
+extern "C" HRESULT WINAPI PIXEndCapture(BOOL discard);
+
+extern "C" DWORD WINAPI PIXGetCaptureState();
+
+extern "C" void WINAPI PIXReportCounter(_In_ PCWSTR name, float value);
+
+#endif // USE_PIX
+
+#endif // (USE_PIX_SUPPORTED_ARCHITECTURE) && (USE_PIX || USE_PIX_RETAIL)
+
+#if !defined(USE_PIX_SUPPORTED_ARCHITECTURE) || !defined(USE_PIX)
+
+// Eliminate these APIs when not using PIX
+inline HRESULT PIXBeginCapture2(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; }
+inline HRESULT PIXBeginCapture(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; }
+inline HRESULT PIXEndCapture(BOOL) { return S_OK; }
+inline HRESULT PIXGpuCaptureNextFrames(PCWSTR, UINT32) { return S_OK; }
+inline HRESULT PIXSetTargetWindow(HWND) { return S_OK; }
+inline HRESULT PIXForceD3D11On12() { return S_OK; }
+inline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions) { return S_OK; }
+inline bool WINAPI PIXIsAttachedForGpuCapture() { return false; }
+inline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR) { return 0; }
+inline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary() { return nullptr; }
+inline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary() { return nullptr; }
+inline DWORD PIXGetCaptureState() { return 0; }
+inline void PIXReportCounter(_In_ PCWSTR, float) {}
+inline void PIXNotifyWakeFromFenceSignal(_In_ HANDLE) {}
+
+#if !defined(USE_PIX_RETAIL)
+
+inline void PIXBeginEvent(UINT64, _In_ PCSTR, ...) {}
+inline void PIXBeginEvent(UINT64, _In_ PCWSTR, ...) {}
+inline void PIXBeginEvent(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXBeginEvent(void*, UINT64, _In_ PCWSTR, ...) {}
+inline void PIXEndEvent() {}
+inline void PIXEndEvent(void*) {}
+inline void PIXSetMarker(UINT64, _In_ PCSTR, ...) {}
+inline void PIXSetMarker(UINT64, _In_ PCWSTR, ...) {}
+inline void PIXSetMarker(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXSetMarker(void*, UINT64, _In_ PCWSTR, ...) {}
+inline void PIXBeginRetailEvent(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXBeginRetailEvent(void*, UINT64, _In_ PCWSTR, ...) {}
+inline void PIXEndRetailEvent(void*) {}
+inline void PIXSetRetailMarker(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXSetRetailMarker(void*, UINT64, _In_ PCWSTR, ...) {}
+inline void PIXScopedEvent(UINT64, _In_ PCSTR, ...) {}
+inline void PIXScopedEvent(UINT64, _In_ PCWSTR, ...) {}
+inline void PIXScopedEvent(void*, UINT64, _In_ PCSTR, ...) {}
+inline void PIXScopedEvent(void*, UINT64, _In_ PCWSTR, ...) {}
+
+#endif // !USE_PIX_RETAIL
+
+// don't show warnings about expressions with no effect
+#pragma warning(disable:4548)
+#pragma warning(disable:4555)
+
+#endif // !USE_PIX_SUPPORTED_ARCHITECTURE || !USE_PIX
+
+// Use these functions to specify colors to pass as metadata to a PIX event/marker API.
+// Use PIX_COLOR() to specify a particular color for an event.
+// Or, use PIX_COLOR_INDEX() to specify a set of unique event categories, and let PIX choose
+// the colors to represent each category.
+inline UINT32 PIX_COLOR(UINT8 r, UINT8 g, UINT8 b) { return 0xff000000u | ((UINT32)r << 16) | ((UINT32)g << 8) | (UINT32)b; }
+inline UINT8 PIX_COLOR_INDEX(UINT8 i) { return i; }
+const UINT8 PIX_COLOR_DEFAULT = PIX_COLOR_INDEX(0);
+
+#endif // _PIX3_H_
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h
new file mode 100644
index 0000000..9fd7baf
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h
@@ -0,0 +1,509 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Don't include this file directly - use pix3.h
+
+#pragma once
+
+#ifndef _PIX3_H_
+#error Don't include this file directly - use pix3.h
+#endif
+
+#ifndef _PIX3_WIN_H_
+#define _PIX3_WIN_H_
+
+// PIXEventsThreadInfo is defined in PIXEventsCommon.h
+struct PIXEventsThreadInfo;
+
+extern "C" PIXEventsThreadInfo* WINAPI PIXGetThreadInfo() noexcept;
+
+#if defined(USE_PIX) && defined(USE_PIX_SUPPORTED_ARCHITECTURE)
+// Notifies PIX that an event handle was set as a result of a D3D12 fence being signaled.
+// The event specified must have the same handle value as the handle
+// used in ID3D12Fence::SetEventOnCompletion.
+extern "C" void WINAPI PIXNotifyWakeFromFenceSignal(_In_ HANDLE event);
+
+// Notifies PIX that a block of memory was allocated
+extern "C" void WINAPI PIXRecordMemoryAllocationEvent(USHORT allocatorId, void* baseAddress, size_t size, UINT64 metadata);
+
+// Notifies PIX that a block of memory was freed
+extern "C" void WINAPI PIXRecordMemoryFreeEvent(USHORT allocatorId, void* baseAddress, size_t size, UINT64 metadata);
+
+#else
+
+// Eliminate these APIs when not using PIX
+inline void PIXRecordMemoryAllocationEvent(USHORT, void*, size_t, UINT64) {}
+inline void PIXRecordMemoryFreeEvent(USHORT, void*, size_t, UINT64) {}
+
+#endif
+
+// The following WINPIX_EVENT_* defines denote the different metadata values that have
+// been used by tools to denote how to parse pix marker event data. The first two values
+// are legacy values used by pix.h in the Windows SDK.
+#define WINPIX_EVENT_UNICODE_VERSION 0
+#define WINPIX_EVENT_ANSI_VERSION 1
+
+// These values denote PIX marker event data that was created by the WinPixEventRuntime.
+// In early 2023 we revised the PIX marker format and defined a new version number.
+#define WINPIX_EVENT_PIX3BLOB_VERSION 2
+#define WINPIX_EVENT_PIX3BLOB_V2 6345127 // A number that other applications are unlikely to have used before
+
+// For backcompat reasons, the WinPixEventRuntime uses the older PIX3BLOB format when it passes data
+// into the D3D12 runtime. It will be updated to use the V2 format in the future.
+#define D3D12_EVENT_METADATA WINPIX_EVENT_PIX3BLOB_VERSION
+
+__forceinline UINT64 PIXGetTimestampCounter()
+{
+    LARGE_INTEGER time = {};
+    QueryPerformanceCounter(&time);
+    return static_cast<UINT64>(time.QuadPart);
+}
+
+enum PIXHUDOptions
+{
+    PIX_HUD_SHOW_ON_ALL_WINDOWS = 0x1,
+    PIX_HUD_SHOW_ON_TARGET_WINDOW_ONLY = 0x2,
+    PIX_HUD_SHOW_ON_NO_WINDOWS = 0x4
+};
+DEFINE_ENUM_FLAG_OPERATORS(PIXHUDOptions);
+
+#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && defined(USE_PIX)
+
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM | WINAPI_PARTITION_GAMES)
+
+#include <shlobj.h>
+#include <strsafe.h>
+#include <knownfolders.h>
+#include <shellapi.h>
+
+#define PIXERRORCHECK(value)  do {                      \
+                                 if (FAILED(value))     \
+                                     return nullptr;    \
+                                 } while(0)
+
+namespace PixImpl
+{
+#ifndef PIX3_WIN_UNIT_TEST
+
+    __forceinline BOOL GetModuleHandleExW(
+        DWORD dwFlags,
+        LPCWSTR lpModuleName,
+        HMODULE* phModule)
+    {
+        return ::GetModuleHandleExW(dwFlags, lpModuleName, phModule);
+    }
+
+    __forceinline HRESULT SHGetKnownFolderPath(
+        REFKNOWNFOLDERID rfid,
+        DWORD dwFlags,
+        HANDLE hToken,
+        PWSTR* ppszPath)
+    {
+        return ::SHGetKnownFolderPath(rfid, dwFlags, hToken, ppszPath);
+    }
+
+    __forceinline void CoTaskMemFree(LPVOID pv)
+    {
+        return ::CoTaskMemFree(pv);
+    }
+
+    __forceinline HANDLE FindFirstFileW(
+        LPCWSTR lpFileName,
+        LPWIN32_FIND_DATAW lpFindFileData)
+    {
+        return ::FindFirstFileW(lpFileName, lpFindFileData);
+    }
+
+    __forceinline DWORD GetFileAttributesW(LPCWSTR lpFileName)
+    {
+        return ::GetFileAttributesW(lpFileName);
+    }
+
+    __forceinline BOOL FindNextFileW(
+        HANDLE hFindFile,
+        LPWIN32_FIND_DATAW lpFindFileData)
+    {
+        return ::FindNextFileW(hFindFile, lpFindFileData);
+    }
+
+    __forceinline BOOL FindClose(HANDLE hFindFile)
+    {
+        return ::FindClose(hFindFile);
+    }
+
+    __forceinline HMODULE LoadLibraryExW(LPCWSTR lpLibFileName, DWORD flags)
+    {
+        return ::LoadLibraryExW(lpLibFileName, NULL, flags);
+    }
+
+#endif // !PIX3_WIN_UNIT_TESTS
+
+    __forceinline void * GetGpuCaptureFunctionPtr(LPCSTR fnName) noexcept
+    {
+        HMODULE module = GetModuleHandleW(L"WinPixGpuCapturer.dll");
+        if (module == NULL)
+        {
+            return nullptr;
+        }
+
+        auto fn = (void*)GetProcAddress(module, fnName);
+        if (fn == nullptr)
+        {
+            return nullptr;
+        }
+
+        return fn;
+    }
+
+    __forceinline void* GetTimingCaptureFunctionPtr(LPCSTR fnName) noexcept
+    {
+        HMODULE module = GetModuleHandleW(L"WinPixTimingCapturer.dll");
+        if (module == NULL)
+        {
+            return nullptr;
+        }
+
+        auto fn = (void*)GetProcAddress(module, fnName);
+        if (fn == nullptr)
+        {
+            return nullptr;
+        }
+
+        return fn;
+    }
+
+    __forceinline HMODULE PIXLoadLatestCapturerLibrary(wchar_t const* capturerDllName, DWORD flags)
+    {
+        HMODULE libHandle{};
+
+        if (PixImpl::GetModuleHandleExW(0, capturerDllName, &libHandle))
+        {
+            return libHandle;
+        }
+
+        LPWSTR programFilesPath = nullptr;
+        if (FAILED(PixImpl::SHGetKnownFolderPath(FOLDERID_ProgramFiles, KF_FLAG_DEFAULT, NULL, &programFilesPath)))
+        {
+            PixImpl::CoTaskMemFree(programFilesPath);
+            return nullptr;
+        }
+
+        wchar_t pixSearchPath[MAX_PATH];
+
+        if (FAILED(StringCchCopyW(pixSearchPath, MAX_PATH, programFilesPath)))
+        {
+            PixImpl::CoTaskMemFree(programFilesPath);
+            return nullptr;
+        }
+        PixImpl::CoTaskMemFree(programFilesPath);
+
+        PIXERRORCHECK(StringCchCatW(pixSearchPath, MAX_PATH, L"\\Microsoft PIX\\*"));
+
+        WIN32_FIND_DATAW findData;
+        bool foundPixInstallation = false;
+        wchar_t newestVersionFound[MAX_PATH];
+        wchar_t output[MAX_PATH];
+        wchar_t possibleOutput[MAX_PATH];
+
+        HANDLE hFind = PixImpl::FindFirstFileW(pixSearchPath, &findData);
+        if (hFind != INVALID_HANDLE_VALUE)
+        {
+            do
+            {
+                if (((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) &&
+                    (findData.cFileName[0] != '.'))
+                {
+                    if (!foundPixInstallation || wcscmp(newestVersionFound, findData.cFileName) <= 0)
+                    {
+                        // length - 1 to get rid of the wildcard character in the search path
+                        PIXERRORCHECK(StringCchCopyNW(possibleOutput, MAX_PATH, pixSearchPath, wcslen(pixSearchPath) - 1));
+                        PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, findData.cFileName));
+                        PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, L"\\"));
+                        PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, capturerDllName));
+
+                        DWORD result = PixImpl::GetFileAttributesW(possibleOutput);
+
+                        if (result != INVALID_FILE_ATTRIBUTES && !(result & FILE_ATTRIBUTE_DIRECTORY))
+                        {
+                            foundPixInstallation = true;
+                            PIXERRORCHECK(StringCchCopyW(newestVersionFound, _countof(newestVersionFound), findData.cFileName));
+                            PIXERRORCHECK(StringCchCopyW(output, _countof(possibleOutput), possibleOutput));
+                        }
+                    }
+                }
+            } while (PixImpl::FindNextFileW(hFind, &findData) != 0);
+        }
+
+        PixImpl::FindClose(hFind);
+
+        if (!foundPixInstallation)
+        {
+            SetLastError(ERROR_FILE_NOT_FOUND);
+            return nullptr;
+        }
+
+        return PixImpl::LoadLibraryExW(output, flags);
+    }
+}
+
+#undef PIXERRORCHECK
+
+__forceinline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary()
+{
+    return PixImpl::PIXLoadLatestCapturerLibrary(
+        L"WinPixGpuCapturer.dll",
+        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+}
+
+__forceinline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary()
+{
+    return PixImpl::PIXLoadLatestCapturerLibrary(
+        L"WinPixTimingCapturer.dll",
+        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR);
+}
+
+__forceinline HRESULT WINAPI PIXSetTargetWindow(HWND hwnd)
+{
+    typedef void(WINAPI* SetGlobalTargetWindowFn)(HWND);
+
+    auto fn = (SetGlobalTargetWindowFn)PixImpl::GetGpuCaptureFunctionPtr("SetGlobalTargetWindow");
+    if (fn == nullptr)
+    {
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    fn(hwnd);
+    return S_OK;
+}
+
+__forceinline HRESULT WINAPI PIXGpuCaptureNextFrames(PCWSTR fileName, UINT32 numFrames)
+{
+    typedef HRESULT(WINAPI* CaptureNextFrameFn)(PCWSTR, UINT32);
+
+    auto fn = (CaptureNextFrameFn)PixImpl::GetGpuCaptureFunctionPtr("CaptureNextFrame");
+    if (fn == nullptr)
+    {
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    return fn(fileName, numFrames);
+}
+
+extern "C"  __forceinline HRESULT WINAPI PIXBeginCapture2(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters)
+{
+    if (captureFlags == PIX_CAPTURE_GPU)
+    {
+        typedef HRESULT(WINAPI* BeginProgrammaticGpuCaptureFn)(const PPIXCaptureParameters);
+
+        auto fn = (BeginProgrammaticGpuCaptureFn)PixImpl::GetGpuCaptureFunctionPtr("BeginProgrammaticGpuCapture");
+        if (fn == nullptr)
+        {
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
+
+        return fn(captureParameters);
+    }
+    else if (captureFlags == PIX_CAPTURE_TIMING)
+    {
+        typedef HRESULT(WINAPI* BeginProgrammaticTimingCaptureFn)(void const*, UINT64);
+
+        auto fn = (BeginProgrammaticTimingCaptureFn)PixImpl::GetTimingCaptureFunctionPtr("BeginProgrammaticTimingCapture");
+        if (fn == nullptr)
+        {
+            return HRESULT_FROM_WIN32(GetLastError());
+        }
+
+        return fn(&captureParameters->TimingCaptureParameters, sizeof(captureParameters->TimingCaptureParameters));
+    }
+    else
+    {
+        return E_NOTIMPL;
+    }
+}
+
+extern "C"  __forceinline HRESULT WINAPI PIXEndCapture(BOOL discard)
+{
+    // We can't tell if the user wants to end a GPU Capture or a Timing Capture.
+    // The user shouldn't have both WinPixGpuCapturer and WinPixTimingCapturer loaded in the process though,
+    // so we can just look for one of them and call it.
+    typedef HRESULT(WINAPI* EndProgrammaticGpuCaptureFn)(void);
+    auto gpuFn = (EndProgrammaticGpuCaptureFn)PixImpl::GetGpuCaptureFunctionPtr("EndProgrammaticGpuCapture");
+    if (gpuFn != NULL)
+    {
+        return gpuFn();
+    }
+
+    typedef HRESULT(WINAPI* EndProgrammaticTimingCaptureFn)(BOOL);
+    auto timingFn = (EndProgrammaticTimingCaptureFn)PixImpl::GetTimingCaptureFunctionPtr("EndProgrammaticTimingCapture");
+    if (timingFn != NULL)
+    {
+        return timingFn(discard);
+    }
+
+    return HRESULT_FROM_WIN32(GetLastError());
+}
+
+__forceinline HRESULT WINAPI PIXForceD3D11On12()
+{
+    typedef HRESULT (WINAPI* ForceD3D11On12Fn)(void);
+
+    auto fn = (ForceD3D11On12Fn)PixImpl::GetGpuCaptureFunctionPtr("ForceD3D11On12");
+    if (fn == NULL)
+    {
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    return fn();
+}
+
+__forceinline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions hudOptions)
+{
+    typedef HRESULT(WINAPI* SetHUDOptionsFn)(PIXHUDOptions);
+
+    auto fn = (SetHUDOptionsFn)PixImpl::GetGpuCaptureFunctionPtr("SetHUDOptions");
+    if (fn == NULL)
+    {
+        return HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    return fn(hudOptions);
+}
+
+__forceinline bool WINAPI PIXIsAttachedForGpuCapture()
+{
+    typedef bool(WINAPI* GetIsAttachedToPixFn)(void);
+    auto fn = (GetIsAttachedToPixFn)PixImpl::GetGpuCaptureFunctionPtr("GetIsAttachedToPix");
+    if (fn == NULL)
+    {
+        OutputDebugStringW(L"WinPixEventRuntime error: Mismatched header/dll. Please ensure that pix3.h and WinPixGpuCapturer.dll match");
+        return false;
+    }
+
+    return fn();
+}
+
+__forceinline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR fileName)
+{
+    return ShellExecuteW(0, 0, fileName, 0, 0, SW_SHOW);
+}
+
+#else
+__forceinline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary()
+{
+    return nullptr;
+}
+__forceinline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary()
+{
+    return nullptr;
+}
+__forceinline HRESULT WINAPI PIXSetTargetWindow(HWND)
+{
+    return E_NOTIMPL;
+}
+
+__forceinline HRESULT WINAPI PIXGpuCaptureNextFrames(PCWSTR, UINT32)
+{
+    return E_NOTIMPL;
+}
+extern "C"  __forceinline HRESULT WINAPI PIXBeginCapture2(DWORD, _In_opt_ const PPIXCaptureParameters)
+{
+    return E_NOTIMPL;
+}
+extern "C"  __forceinline HRESULT WINAPI PIXEndCapture(BOOL)
+{
+    return E_NOTIMPL;
+}
+__forceinline HRESULT WINAPI PIXForceD3D11On12()
+{
+    return E_NOTIMPL;
+}
+__forceinline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions)
+{
+    return E_NOTIMPL;
+}
+__forceinline bool WINAPI PIXIsAttachedForGpuCapture()
+{
+    return false;
+}
+__forceinline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR)
+{
+    return 0;
+}
+#endif // WINAPI_PARTITION
+
+#endif // USE_PIX_SUPPORTED_ARCHITECTURE || USE_PIX
+
+#if defined(__d3d12_h__)
+
+inline void PIXInsertTimingMarkerOnContextForBeginEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandList->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertTimingMarkerOnContextForBeginEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandQueue->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertTimingMarkerOnContextForSetMarker(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandList->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertTimingMarkerOnContextForSetMarker(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandQueue->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertTimingMarkerOnContextForEndEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandList->EndEvent();
+}
+
+inline void PIXInsertTimingMarkerOnContextForEndEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandQueue->EndEvent();
+}
+
+inline void PIXInsertGPUMarkerOnContextForBeginEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandList->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertGPUMarkerOnContextForBeginEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandQueue->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertGPUMarkerOnContextForSetMarker(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandList->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertGPUMarkerOnContextForSetMarker(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size)
+{
+    UNREFERENCED_PARAMETER(eventType);
+    commandQueue->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size);
+}
+
+inline void PIXInsertGPUMarkerOnContextForEndEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8, void*, UINT)
+{
+    commandList->EndEvent();
+}
+
+inline void PIXInsertGPUMarkerOnContextForEndEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8, void*, UINT)
+{
+    commandQueue->EndEvent();
+}
+
+#endif
+
+#endif //_PIX3_WIN_H_
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.dll b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.dll
new file mode 100644
index 0000000..6273f1f
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.dll differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.lib b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.lib
new file mode 100644
index 0000000..04198a5
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime.lib differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.dll b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.dll
new file mode 100644
index 0000000..0c16945
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.dll differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.lib b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.lib
new file mode 100644
index 0000000..6dc8a05
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/ARM64/WinPixEventRuntime_UAP.lib differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll
new file mode 100644
index 0000000..5d86359
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib
new file mode 100644
index 0000000..7a909a8
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll
new file mode 100644
index 0000000..0b1226c
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll differ
diff --git a/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.lib b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.lib
new file mode 100644
index 0000000..cc2156f
Binary files /dev/null and b/Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.lib differ
diff --git a/Coplt.Graphics.sln b/Coplt.Graphics.sln
index 397a044..2b035cc 100644
--- a/Coplt.Graphics.sln
+++ b/Coplt.Graphics.sln
@@ -6,13 +6,13 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Examples", "Examples", "{DB
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloTriangle", "Examples\HelloTriangle\HelloTriangle.csproj", "{2ABF3CFF-8E44-4992-A633-491B2AAA5BFB}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Coplt.Graphics.Native.D3d12", "Coplt.Graphics.Native.D3d12\Coplt.Graphics.Native.D3d12.csproj", "{9B2BF8A4-3978-4639-B8D8-20C75138CDC9}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Coplt.Graphics.Native.D3d12.Win64", "Coplt.Graphics.Native.D3d12.Win64\Coplt.Graphics.Native.D3d12.Win64.csproj", "{9B2BF8A4-3978-4639-B8D8-20C75138CDC9}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExampleBase", "Examples\ExampleBase\ExampleBase.csproj", "{B4F50522-B216-413B-AEC5-ED6D9114D1EE}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloTriangleVertex", "Examples\HelloTriangleVertex\HelloTriangleVertex.csproj", "{1173C015-4D34-4DD1-85F6-98C68FDC50BB}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RotatingCube", "Examples\RotatingCube\RotatingCube.csproj", "{C4C82737-D197-447B-B663-2DEFE3CE6679}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Colorful", "Examples\Colorful\Colorful.csproj", "{C4C82737-D197-447B-B663-2DEFE3CE6679}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/Examples/RotatingCube/App.xaml b/Examples/Colorful/App.xaml
similarity index 100%
rename from Examples/RotatingCube/App.xaml
rename to Examples/Colorful/App.xaml
diff --git a/Examples/RotatingCube/App.xaml.cs b/Examples/Colorful/App.xaml.cs
similarity index 100%
rename from Examples/RotatingCube/App.xaml.cs
rename to Examples/Colorful/App.xaml.cs
diff --git a/Examples/RotatingCube/AssemblyInfo.cs b/Examples/Colorful/AssemblyInfo.cs
similarity index 100%
rename from Examples/RotatingCube/AssemblyInfo.cs
rename to Examples/Colorful/AssemblyInfo.cs
diff --git a/Examples/RotatingCube/RotatingCube.csproj b/Examples/Colorful/Colorful.csproj
similarity index 95%
rename from Examples/RotatingCube/RotatingCube.csproj
rename to Examples/Colorful/Colorful.csproj
index 219957c..a61559b 100644
--- a/Examples/RotatingCube/RotatingCube.csproj
+++ b/Examples/Colorful/Colorful.csproj
@@ -70,5 +70,6 @@
         <None Include="../../build/debug/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/debug/bin/**/*.pdb" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/release/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' != 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
+        <None Include="../../Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll" Visible="false" CopyToOutputDirectory="PreserveNewest"/>
     </ItemGroup>
 </Project>
diff --git a/Examples/Colorful/Example.cs b/Examples/Colorful/Example.cs
new file mode 100644
index 0000000..eed5976
--- /dev/null
+++ b/Examples/Colorful/Example.cs
@@ -0,0 +1,67 @@
+using Coplt.Graphics;
+using Coplt.Graphics.Core;
+using Coplt.Graphics.States;
+using Coplt.Mathematics;
+
+namespace Examples;
+
+public class Example(IntPtr Handle, uint Width, uint Height) : ExampleBase(Handle, Width, Height)
+{
+    private ShaderLayout Layout = null!;
+    private Shader Shader = null!;
+    private GraphicsShaderPipeline Pipeline = null!;
+    private ShaderBinding ShaderBinding = null!;
+    private GpuBuffer ArgBuffer = null!;
+
+    public override string Name => "Colorful";
+    protected override async Task LoadResources(CommandList cmd)
+    {
+        var modules = await LoadShaderModules("Shader", [ShaderStage.Vertex, ShaderStage.Pixel]);
+        Layout = Device.CreateShaderLayout(
+            [
+                new()
+                {
+                    Slot = 0,
+                    Stage = ShaderStage.Pixel,
+                    View = ShaderLayoutItemView.Cbv,
+                    Type = ShaderLayoutItemType.ConstantBuffer,
+                    Usage = ShaderLayoutItemUsage.Common,
+                }
+            ],
+            Name: Name
+        );
+        Shader = Device.CreateShader(modules, Layout);
+        ShaderBinding = Device.CreateShaderBinding(Layout, Name: Name);
+        Pipeline = Device.CreateGraphicsShaderPipeline(
+            Shader, new()
+            {
+                DsvFormat = GraphicsFormat.Unknown,
+                BlendState =
+                {
+                    Rt0 =
+                    {
+                        Src = BlendType.SrcAlpha,
+                        Dst = BlendType.InvSrcAlpha,
+                        Op = BlendOp.Add,
+                    }
+                },
+                Topology = PrimitiveTopologyType.TriangleStrip,
+            }, Name: Name
+        );
+        ArgBuffer = Device.CreateBuffer(
+            new()
+            {
+                Purpose = ResourcePurpose.ConstantBuffer,
+                Size = sizeof(float),
+            },
+            Name: "Args"
+        );
+        // cmd.Bind(ShaderBinding, [new(0, ArgBuffer)]);
+    }
+    protected override void Render(CommandList cmd, Time time)
+    {
+        cmd.Upload(ArgBuffer, [(float)time.Total.TotalSeconds]);
+        using var render = cmd.Render([new(Output, new float4(0.83f, 0.8f, 0.97f, 1f))]);
+        render.Draw(Pipeline, 4);
+    }
+}
diff --git a/Examples/RotatingCube/MainWindow.xaml b/Examples/Colorful/MainWindow.xaml
similarity index 100%
rename from Examples/RotatingCube/MainWindow.xaml
rename to Examples/Colorful/MainWindow.xaml
diff --git a/Examples/RotatingCube/MainWindow.xaml.cs b/Examples/Colorful/MainWindow.xaml.cs
similarity index 100%
rename from Examples/RotatingCube/MainWindow.xaml.cs
rename to Examples/Colorful/MainWindow.xaml.cs
diff --git a/Examples/RotatingCube/Properties/launchSettings.json b/Examples/Colorful/Properties/launchSettings.json
similarity index 100%
rename from Examples/RotatingCube/Properties/launchSettings.json
rename to Examples/Colorful/Properties/launchSettings.json
diff --git a/Examples/Colorful/Shaders/Shader.hlsl b/Examples/Colorful/Shaders/Shader.hlsl
new file mode 100644
index 0000000..be05d9c
--- /dev/null
+++ b/Examples/Colorful/Shaders/Shader.hlsl
@@ -0,0 +1,36 @@
+struct Attribute
+{
+    uint VertexID : SV_VertexID;
+};
+
+struct Varying
+{
+    float4 PositionCS : SV_Position;
+    float2 Uv : UV;
+};
+
+float4 GetQuadVertexPosition(out float2 uv, uint vid, float z = 1)
+{
+    float2 uv_ = float2((vid << 1) & 2, vid & 2);
+    uv = uv_ * 0.5f;
+    return float4(uv_ * float2(1, -1) + float2(-1, 1), z, 1);
+}
+
+[shader("vertex")]
+Varying Vertex(Attribute input)
+{
+    Varying output;
+    output.PositionCS = GetQuadVertexPosition(output.Uv, input.VertexID);
+    return output;
+}
+
+cbuffer Args : register(b0)
+{
+    float time;
+} 
+
+[shader("pixel")]
+float4 Pixel(Varying input) : SV_Target
+{
+    return float4(input.Uv, time, 1);
+}
diff --git a/Examples/ExampleBase/ExampleBase.cs b/Examples/ExampleBase/ExampleBase.cs
index e1d7234..0016f10 100644
--- a/Examples/ExampleBase/ExampleBase.cs
+++ b/Examples/ExampleBase/ExampleBase.cs
@@ -1,4 +1,5 @@
-using Coplt.Graphics;
+using System.Diagnostics;
+using Coplt.Graphics;
 using Coplt.Graphics.Core;
 using Serilog;
 
@@ -11,7 +12,7 @@ public abstract class ExampleBase(IntPtr Handle, uint Width, uint Height)
     public GpuDevice Device = null!;
     public GpuOutput Output = null!;
     public IntPtr Handle = Handle;
-    
+
     public abstract string Name { get; }
 
     #region InitGraphics
@@ -22,12 +23,21 @@ public void DoInitGraphics()
     {
         try
         {
-            Graphics = GraphicsInstance.LoadD3d12();
+            Graphics = GraphicsInstance.LoadD3d12(Debug: true);
             Graphics.SetLogger(
                 (level, _) => Log.IsEnabled(level.ToLogEventLevel()),
                 (level, scope, msg) => Log.Write(level.ToLogEventLevel(), "[{Scope}] {Msg}", scope, msg)
             );
-            Device = Graphics.CreateDevice(Debug: true, Name: "Main Device");
+            Device = Graphics.CreateDevice(Name: "Main Device");
+            var Adapter = Device.Adapter;
+            Log.Information(
+                "Selected device: {@Info}",
+                new
+                {
+                    Adapter.Name, Adapter.VendorId, Adapter.DeviceId, Adapter.Driver, Adapter.Backend,
+                    Adapter.Features.ShaderModelLevel
+                }
+            );
             Output = Device.MainQueue.CreateOutputForHwnd(
                 new()
                 {
@@ -37,31 +47,43 @@ public void DoInitGraphics()
                 }, Handle
             );
             InitGraphics();
+            new Thread(
+                () =>
+                {
+                    Thread.CurrentThread.Name = "Render Thread";
+                    var cmd = Device.MainCommandList;
+                    LoadResources(cmd).Wait();
+                    var start_time = Stopwatch.GetTimestamp();
+                    var last_time = start_time;
+                    while (!IsClosed)
+                    {
+                        try
+                        {
+                            var now_time = Stopwatch.GetTimestamp();
+                            var total_time = Stopwatch.GetElapsedTime(start_time, now_time);
+                            var delta_time = Stopwatch.GetElapsedTime(last_time, now_time);
+                            last_time = now_time;
+                            var time = new Time
+                            {
+                                Total = total_time,
+                                Delta = delta_time
+                            };
+
+                            Render(cmd, time);
+                            Output.Present();
+                        }
+                        catch (Exception e)
+                        {
+                            Log.Error(e, "");
+                        }
+                    }
+                }
+            ).Start();
         }
         catch (Exception e)
         {
             Log.Error(e, "");
         }
-        new Thread(
-            () =>
-            {
-                Thread.CurrentThread.Name = "Render Thread";
-                var cmd = Device.MainCommandList;
-                LoadResources(cmd).Wait();
-                while (!IsClosed)
-                {
-                    try
-                    {
-                        Render(cmd);
-                        Output.Present();
-                    }
-                    catch (Exception e)
-                    {
-                        Log.Error(e, "");
-                    }
-                }
-            }
-        ).Start();
     }
 
     #endregion
@@ -94,7 +116,7 @@ protected Task<ShaderModule[]> LoadShaderModules(string name, ReadOnlySpan<Shade
 
     #region Render
 
-    protected abstract void Render(CommandList cmd);
+    protected abstract void Render(CommandList cmd, Time time);
 
     #endregion
 }
diff --git a/Examples/ExampleBase/ExampleBase.csproj b/Examples/ExampleBase/ExampleBase.csproj
index fc536ff..0d0e230 100644
--- a/Examples/ExampleBase/ExampleBase.csproj
+++ b/Examples/ExampleBase/ExampleBase.csproj
@@ -8,7 +8,7 @@
 
     <ItemGroup>
         <ProjectReference Include="..\..\Coplt.Graphics.Core\Coplt.Graphics.Core.csproj" />
-        <ProjectReference Include="..\..\Coplt.Graphics.Native.D3d12\Coplt.Graphics.Native.D3d12.csproj" />
+        <ProjectReference Include="..\..\Coplt.Graphics.Native.D3d12.Win64\Coplt.Graphics.Native.D3d12.Win64.csproj" />
         <PackageReference Include="Serilog" Version="4.2.0"/>
         <PackageReference Include="Serilog.Enrichers.Thread" Version="4.0.0"/>
         <PackageReference Include="Serilog.Exceptions" Version="8.4.0"/>
diff --git a/Examples/ExampleBase/Time.cs b/Examples/ExampleBase/Time.cs
new file mode 100644
index 0000000..86a9d74
--- /dev/null
+++ b/Examples/ExampleBase/Time.cs
@@ -0,0 +1,7 @@
+namespace Examples;
+
+public record struct Time
+{
+    public TimeSpan Total;
+    public TimeSpan Delta;
+}
diff --git a/Examples/HelloTriangle/Example.cs b/Examples/HelloTriangle/Example.cs
index e4d5c8a..4729064 100644
--- a/Examples/HelloTriangle/Example.cs
+++ b/Examples/HelloTriangle/Example.cs
@@ -9,7 +9,7 @@ public class Example(IntPtr Handle, uint Width, uint Height) : ExampleBase(Handl
 {
     private Shader Shader = null!;
     private GraphicsShaderPipeline Pipeline = null!;
-    
+
     public override string Name => "Hello Triangle";
     protected override async Task LoadResources(CommandList cmd)
     {
@@ -31,10 +31,9 @@ protected override async Task LoadResources(CommandList cmd)
             }, Name: Name
         );
     }
-    protected override void Render(CommandList cmd)
+    protected override void Render(CommandList cmd, Time time)
     {
-        cmd.SetRenderTargets([Output]);
-        cmd.ClearColor(Output, new float4(0.83f, 0.8f, 0.97f, 1f));
-        cmd.Draw(Pipeline, 3);
+        using var render = cmd.Render([new(Output, new float4(0.83f, 0.8f, 0.97f, 1f))]);
+        render.Draw(Pipeline, 3);
     }
 }
diff --git a/Examples/HelloTriangle/HelloTriangle.csproj b/Examples/HelloTriangle/HelloTriangle.csproj
index 219957c..a61559b 100644
--- a/Examples/HelloTriangle/HelloTriangle.csproj
+++ b/Examples/HelloTriangle/HelloTriangle.csproj
@@ -70,5 +70,6 @@
         <None Include="../../build/debug/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/debug/bin/**/*.pdb" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/release/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' != 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
+        <None Include="../../Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll" Visible="false" CopyToOutputDirectory="PreserveNewest"/>
     </ItemGroup>
 </Project>
diff --git a/Examples/HelloTriangle/HelloTriangle.md b/Examples/HelloTriangle/HelloTriangle.md
index 129fdad..4af2188 100644
--- a/Examples/HelloTriangle/HelloTriangle.md
+++ b/Examples/HelloTriangle/HelloTriangle.md
@@ -54,8 +54,7 @@ while (!IsClosed)
 
 void Render(CommandList cmd)
 {
-    cmd.SetRenderTargets([Output]);
-    cmd.ClearColor(Output, new float4(0.83f, 0.8f, 0.97f, 1f));
-    cmd.Draw(Pipeline, 3);
+    using var render = cmd.Render([new(Output, new float4(0.83f, 0.8f, 0.97f, 1f))]);
+    render.Draw(Pipeline, 3);
 }
 ```
diff --git a/Examples/HelloTriangleVertex/Example.cs b/Examples/HelloTriangleVertex/Example.cs
index 27ae50f..c1bb277 100644
--- a/Examples/HelloTriangleVertex/Example.cs
+++ b/Examples/HelloTriangleVertex/Example.cs
@@ -82,16 +82,15 @@ protected override async Task LoadResources(CommandList cmd)
             ]
         );
     }
-    protected override void Render(CommandList cmd)
+    protected override void Render(CommandList cmd, Time time)
     {
-        cmd.SetRenderTargets([Output]);
-        cmd.ClearColor(Output, new float4(0.83f, 0.8f, 0.97f, 1f));
-        cmd.SetMeshBuffers(
+        using var render = cmd.Render([new(Output, new float4(0.83f, 0.8f, 0.97f, 1f))]);
+        render.SetMeshBuffers(
             MeshLayout, [
                 new(0, PositionColorBuffer),
                 new(1, UvBuffer),
             ]
         );
-        cmd.Draw(Pipeline, 3);
+        render.Draw(Pipeline, 3);
     }
 }
diff --git a/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj b/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
index 219957c..a61559b 100644
--- a/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
+++ b/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
@@ -70,5 +70,6 @@
         <None Include="../../build/debug/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/debug/bin/**/*.pdb" Visible="false" Condition="'$(Configuration)' == 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
         <None Include="../../build/release/bin/**/*.dll" Visible="false" Condition="'$(Configuration)' != 'Debug'" CopyToOutputDirectory="PreserveNewest"/>
+        <None Include="../../Coplt.Graphics.Native/D3d12/ThirdParty/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll" Visible="false" CopyToOutputDirectory="PreserveNewest"/>
     </ItemGroup>
 </Project>
diff --git a/Examples/RotatingCube/Example.cs b/Examples/RotatingCube/Example.cs
deleted file mode 100644
index 4eb23d5..0000000
--- a/Examples/RotatingCube/Example.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using Coplt.Graphics;
-using Coplt.Graphics.Core;
-using Coplt.Graphics.States;
-using Coplt.Mathematics;
-
-namespace Examples;
-
-public class Example(IntPtr Handle, uint Width, uint Height) : ExampleBase(Handle, Width, Height)
-{
-    private Shader Shader = null!;
-    private MeshLayout MeshLayout = null!;
-    private GraphicsShaderPipeline Pipeline = null!;
-    private GpuBuffer MeshBuffer = null!;
-
-    public override string Name => "Rotating Cube";
-    protected override async Task LoadResources(CommandList cmd)
-    {
-        var SlotId_Position = Graphics.GetSlotId("Position");
-        var modules = await LoadShaderModules("Shader", [ShaderStage.Vertex, ShaderStage.Pixel]);
-        Shader = Device.CreateShader(
-            modules, null,
-            Device.CreateShaderInputLayout([new("Position", SlotId: SlotId_Position)])
-        );
-        MeshLayout = Device.CreateMeshLayout(
-            [new(sizeof(float) * 4)],
-            [new(SlotId_Position, GraphicsFormat.R32G32B32A32_Float)],
-            Name: "Cube"
-        );
-        Pipeline = Device.CreateGraphicsShaderPipeline(
-            Shader, new() { DsvFormat = GraphicsFormat.Unknown, }, MeshLayout, Name: Name
-        );
-        MeshBuffer = Device.CreateBuffer(
-            new()
-            {
-                Purpose = ResourcePurpose.VertexBuffer,
-                Size = sizeof(float) * 4 * 3 * 2,
-            }, "Cube Mesh"
-        );
-        cmd.Upload(
-            MeshBuffer, [
-                new float4(0.0f, 0.5f * 1.7f, 0f, 1f),
-                new float4(0.5f, -0.5f * 1.7f, 0f, 1f),
-                new float4(-0.5f, -0.5f * 1.7f, 0f, 1f),
-            ]
-        );
-    }
-    protected override void Render(CommandList cmd)
-    {
-        cmd.SetRenderTargets([Output]);
-        cmd.ClearColor(Output, new float4(0.83f, 0.8f, 0.97f, 1f));
-        cmd.SetMeshBuffers(MeshLayout, [new(0, MeshBuffer)]);
-        cmd.Draw(Pipeline, 3);
-    }
-}
diff --git a/Examples/RotatingCube/Shaders/Shader.hlsl b/Examples/RotatingCube/Shaders/Shader.hlsl
deleted file mode 100644
index ac203b0..0000000
--- a/Examples/RotatingCube/Shaders/Shader.hlsl
+++ /dev/null
@@ -1,27 +0,0 @@
-struct Attribute
-{
-    float4 PositionCS : Position;
-};
-
-struct Varying
-{
-    float4 PositionCS : SV_Position;
-    // float4 Color : Color;
-    // float2 Uv : Uv;
-};
-
-[shader("vertex")]
-Varying Vertex(Attribute input)
-{
-    Varying output;
-    output.PositionCS = input.PositionCS;
-    // output.Color = Colors[input.VertexID % 3];
-    // output.Uv = Uvs[input.VertexID % 3];
-    return output;
-}
-
-[shader("pixel")]
-float4 Pixel(Varying input) : SV_Target
-{
-    return float4(1, 1, 1, 1);
-}
diff --git a/ThirdParty/concurrentqueue b/ThirdParty/concurrentqueue
new file mode 160000
index 0000000..0d54c67
--- /dev/null
+++ b/ThirdParty/concurrentqueue
@@ -0,0 +1 @@
+Subproject commit 0d54c6794510018f42b1b987f55c313dd1358320
diff --git a/ThirdParty/cpptrace b/ThirdParty/cpptrace
index 6689d14..1940dc6 160000
--- a/ThirdParty/cpptrace
+++ b/ThirdParty/cpptrace
@@ -1 +1 @@
-Subproject commit 6689d14c203eed390ae7bb64f56a983cfd7dff9c
+Subproject commit 1940dc607aa09fd9014c650aa305f363284919fa
diff --git a/ThirdParty/emhash b/ThirdParty/emhash
deleted file mode 160000
index e2987ec..0000000
--- a/ThirdParty/emhash
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e2987ec7c0d35b2e0e3d5a2a2727d208ddbba468