diff --git a/CMake/Target.cmake b/CMake/Target.cmake
index 9b1914bac..41cbdd852 100644
--- a/CMake/Target.cmake
+++ b/CMake/Target.cmake
@@ -337,7 +337,7 @@ function(AddExecutable)
     endif()
 
     if (${MSVC})
-        set_target_properties(${PARAMS_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>)
+        set_target_properties(${PARAMS_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
     endif()
 endfunction()
 
diff --git a/Editor/Include/Editor/QmlEngine.h b/Editor/Include/Editor/QmlEngine.h
index b4184d95a..23a411c87 100644
--- a/Editor/Include/Editor/QmlEngine.h
+++ b/Editor/Include/Editor/QmlEngine.h
@@ -32,6 +32,6 @@ namespace Editor {
 
         Common::Path qmlSourceDir;
         std::unordered_set<QmlWidget*> widgets;
-        Common::UniqueRef<QFileSystemWatcher> watcher;
+        Common::UniquePtr<QFileSystemWatcher> watcher;
     };
 }
diff --git a/Editor/Src/Main.cpp b/Editor/Src/Main.cpp
index fc58154b5..f5569fa59 100644
--- a/Editor/Src/Main.cpp
+++ b/Editor/Src/Main.cpp
@@ -25,7 +25,7 @@ int main(int argc, char* argv[])
     auto& qmlEngine = Editor::QmlEngine::Get();
     qmlEngine.Start();
 
-    Common::UniqueRef<QWidget> mainWidget;
+    Common::UniquePtr<QWidget> mainWidget;
 #if BUILD_CONFIG_DEBUG
     if (caRunSample.GetValue()) {
         mainWidget = new Editor::WidgetSamples();
diff --git a/Engine/Source/Common/Include/Common/Concurrent.h b/Engine/Source/Common/Include/Common/Concurrent.h
index b3b1f6a0e..070c814c9 100644
--- a/Engine/Source/Common/Include/Common/Concurrent.h
+++ b/Engine/Source/Common/Include/Common/Concurrent.h
@@ -4,17 +4,17 @@
 
 #pragma once
 
+#include <string>
 #include <vector>
 #include <queue>
 #include <mutex>
 #include <thread>
 #include <future>
-#include <memory>
 #include <functional>
 #include <type_traits>
 
-#include <Common/String.h>
 #include <Common/Debug.h>
+#include <Common/Memory.h>
 #include <Common/Utility.h>
 
 namespace Common {
@@ -24,8 +24,7 @@ namespace Common {
 
         NamedThread();
 
-        template <typename F, typename... Args>
-        explicit NamedThread(const std::string& name, F&& task, Args&&... args);
+        template <typename F> explicit NamedThread(const std::string& name, F&& task);
 
         void Join();
 
@@ -40,10 +39,12 @@ namespace Common {
         ThreadPool(const std::string& name, uint8_t threadNum);
         ~ThreadPool();
 
-        template <typename F, typename... Args>
-        auto EmplaceTask(F&& task, Args&&... args);
+        template <typename F> auto EmplaceTask(F&& task);
+        template <typename F> void ExecuteTasks(size_t taskNum, F&& task);
 
     private:
+        template <typename Ret> auto EmplaceTaskInternal(Common::SharedPtr<std::packaged_task<Ret()>> packedTask);
+
         bool stop;
         std::mutex mutex;
         std::condition_variable condition;
@@ -58,8 +59,7 @@ namespace Common {
 
         void Flush();
 
-        template <typename F, typename... Args>
-        auto EmplaceTask(F&& task, Args&&... args);
+        template <typename F> auto EmplaceTask(F&& task);
 
     private:
         bool stop;
@@ -73,35 +73,56 @@ namespace Common {
 }
 
 namespace Common {
-    template <typename F, typename... Args>
-    NamedThread::NamedThread(const std::string& name, F&& task, Args&& ... args)
+    template <typename F>
+    NamedThread::NamedThread(const std::string& name, F&& task)
     {
-        thread = std::thread([this, task = std::forward<F>(task), name](Args&&... args) -> void {
+        thread = std::thread([this, task, name]() -> void {
             SetThreadName(name);
-            task(args...);
-        }, std::forward<Args>(args)...);
+            task();
+        });
     }
 
-    template <typename F, typename... Args>
-    auto ThreadPool::EmplaceTask(F&& task, Args&& ... args)
+    template <typename F>
+    auto ThreadPool::EmplaceTask(F&& task)
     {
-        using RetType = std::invoke_result_t<F, Args...>;
-        auto packagedTask = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(task), std::forward<Args>(args)...));
-        auto result = packagedTask->get_future();
+        using RetType = std::invoke_result_t<F>;
+        return EmplaceTaskInternal<RetType>(Common::MakeShared<std::packaged_task<RetType()>>(task));
+    }
+
+    template <typename F>
+    void ThreadPool::ExecuteTasks(size_t taskNum, F&& task)
+    {
+        using RetType = std::invoke_result_t<F, size_t>;
+
+        std::vector<std::future<RetType>> futures;
+        futures.reserve(taskNum);
+        for (size_t i = 0; i < taskNum; i++) {
+            futures.emplace_back(EmplaceTaskInternal<RetType>(Common::MakeShared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(task), i))));
+        }
+
+        for (const auto& future : futures) {
+            future.wait();
+        }
+    }
+
+    template <typename Ret>
+    auto ThreadPool::EmplaceTaskInternal(Common::SharedPtr<std::packaged_task<Ret()>> packedTask)
+    {
+        auto result = packedTask->get_future();
         {
             std::unique_lock lock(mutex);
             Assert(!stop);
-            tasks.emplace([packagedTask]() -> void { (*packagedTask)(); });
+            tasks.emplace([packedTask]() -> void { (*packedTask)(); });
         }
         condition.notify_one();
         return result;
     }
 
-    template <typename F, typename... Args>
-    auto WorkerThread::EmplaceTask(F&& task, Args&& ... args)
+    template <typename F>
+    auto WorkerThread::EmplaceTask(F&& task)
     {
-        using RetType = std::invoke_result_t<F, Args...>;
-        auto packagedTask = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(task), std::forward<Args>(args)...));
+        using RetType = std::invoke_result_t<F>;
+        auto packagedTask = Common::MakeShared<std::packaged_task<RetType()>>(task);
         auto result = packagedTask->get_future();
         {
             std::unique_lock lock(mutex);
diff --git a/Engine/Source/Common/Include/Common/Memory.h b/Engine/Source/Common/Include/Common/Memory.h
index 5f74bccec..db04297f6 100644
--- a/Engine/Source/Common/Include/Common/Memory.h
+++ b/Engine/Source/Common/Include/Common/Memory.h
@@ -11,448 +11,465 @@
 
 namespace Common {
     template <typename T>
-    class UniqueRef {
+    class UniquePtr {
     public:
-        NonCopyable(UniqueRef)
-        UniqueRef(T* pointer); // NOLINT
-        UniqueRef(std::unique_ptr<T>&& inRef); // NOLINT
-        UniqueRef(UniqueRef&& other) noexcept; // NOLINT
-        UniqueRef();
-        ~UniqueRef();
+        NonCopyable(UniquePtr)
+        UniquePtr(T* pointer); // NOLINT
+        UniquePtr(std::unique_ptr<T>&& uniquePtr); // NOLINT
+        UniquePtr(UniquePtr&& other) noexcept; // NOLINT
+        UniquePtr();
+        ~UniquePtr();
 
-        UniqueRef& operator=(T* pointer);
-        UniqueRef& operator=(std::unique_ptr<T>&& inRef);
-        UniqueRef& operator=(UniqueRef&& other) noexcept;
+        UniquePtr& operator=(T* pointer);
+        UniquePtr& operator=(std::unique_ptr<T>&& uniquePtr);
+        UniquePtr& operator=(UniquePtr&& other) noexcept;
 
         T* operator->() const noexcept;
         T& operator*() const noexcept;
         bool operator==(nullptr_t) const noexcept;
         bool operator!=(nullptr_t) const noexcept;
+        explicit operator bool() const noexcept;
 
+        bool Valid() const;
         T* Get() const;
         void Reset(T* pointer = nullptr);
+        std::unique_ptr<T>& GetStd();
 
     private:
-        std::unique_ptr<T> ref;
+        std::unique_ptr<T> ptr;
     };
 
     template <typename T>
-    class SharedRef {
+    class SharedPtr {
     public:
-        template <typename T2>
-        SharedRef(std::shared_ptr<T2>& inRef); // NOLINT
-
-        template <typename T2>
-        SharedRef(std::shared_ptr<T2>&& inRef) noexcept; // NOLINT
-
-        template <typename T2>
-        SharedRef(std::unique_ptr<T2>&& inRef) noexcept; // NOLINT
-
-        template <typename T2>
-        SharedRef(UniqueRef<T2>&& inRef) noexcept; // NOLINT
-
-        SharedRef(T* pointer); // NOLINT
-        SharedRef(const SharedRef& other); // NOLINT
-        SharedRef(SharedRef&& other) noexcept; // NOLINT
-        SharedRef();
-        ~SharedRef();
-
-        template <typename T2>
-        SharedRef& operator=(std::shared_ptr<T2>& inRef);
-
-        template <typename T2>
-        SharedRef& operator=(std::shared_ptr<T2>&& inRef);
-
-        template <typename T2>
-        SharedRef& operator=(std::unique_ptr<T2>&& inRef) noexcept;
-
-        template <typename T2>
-        SharedRef& operator=(UniqueRef<T2>&& inRef) noexcept;
-
-        SharedRef& operator=(T* pointer);
-        SharedRef& operator=(SharedRef& other); // NOLINT
-        SharedRef& operator=(SharedRef&& other) noexcept;
+        template <typename T2> SharedPtr(std::shared_ptr<T2>& sharedPtr); // NOLINT
+        template <typename T2> SharedPtr(std::shared_ptr<T2>&& sharedPtr) noexcept; // NOLINT
+        template <typename T2> SharedPtr(std::unique_ptr<T2>&& uniquePtr) noexcept; // NOLINT
+        template <typename T2> SharedPtr(UniquePtr<T2>&& uniquePtr) noexcept; // NOLINT
+
+        SharedPtr(T* pointer); // NOLINT
+        SharedPtr(const SharedPtr& other); // NOLINT
+        SharedPtr(SharedPtr&& other) noexcept; // NOLINT
+        SharedPtr();
+        ~SharedPtr();
+
+        template <typename T2> SharedPtr& operator=(std::shared_ptr<T2>& sharedPtr);
+        template <typename T2> SharedPtr& operator=(std::shared_ptr<T2>&& sharedPtr);
+        template <typename T2> SharedPtr& operator=(std::unique_ptr<T2>&& uniquePtr) noexcept;
+        template <typename T2> SharedPtr& operator=(UniquePtr<T2>&& uniquePtr) noexcept;
+
+        SharedPtr& operator=(T* pointer);
+        SharedPtr& operator=(SharedPtr& other); // NOLINT
+        SharedPtr& operator=(SharedPtr&& other) noexcept;
         T* operator->() const noexcept;
         T& operator*() const noexcept;
         bool operator==(nullptr_t) const noexcept;
         bool operator!=(nullptr_t) const noexcept;
+        explicit operator bool() const noexcept;
 
+        bool Valid() const;
         T* Get() const;
         void Reset(T* pointer = nullptr);
         auto RefCount() const;
         std::shared_ptr<T>& GetStd();
 
-        template <typename T2>
-        SharedRef<T2> StaticCast();
-
-        template <typename T2>
-        SharedRef<T2> DynamicCast();
-
-        template <typename T2>
-        SharedRef<T2> ReinterpretCast();
+        template <typename T2> SharedPtr<T2> StaticCast();
+        template <typename T2> SharedPtr<T2> DynamicCast();
+        template <typename T2> SharedPtr<T2> ReinterpretCast();
 
     private:
-        std::shared_ptr<T> ref;
+        std::shared_ptr<T> ptr;
     };
 
     template <typename T>
-    class WeakRef {
+    class WeakPtr {
     public:
-        template <typename T2>
-        WeakRef(SharedRef<T2>& inRef); // NOLINT
-
-        WeakRef(WeakRef& other); // NOLINT
-        WeakRef(WeakRef&& other) noexcept; // NOLINT
-        ~WeakRef();
+        template <typename T2> WeakPtr(SharedPtr<T2>& sharedPtr); // NOLINT
 
-        template <typename T2>
-        WeakRef& operator=(SharedRef<T2>& inRef);
+        WeakPtr(WeakPtr& other); // NOLINT
+        WeakPtr(WeakPtr&& other) noexcept; // NOLINT
+        ~WeakPtr();
 
-        WeakRef& operator=(WeakRef& other); // NOLINT
-        WeakRef& operator=(WeakRef&& other) noexcept;
+        template <typename T2> WeakPtr& operator=(SharedPtr<T2>& sharedPtr);
+        WeakPtr& operator=(WeakPtr& other); // NOLINT
+        WeakPtr& operator=(WeakPtr&& other) noexcept;
 
         void Reset();
         bool Expired() const;
-        SharedRef<T> Lock() const;
+        SharedPtr<T> Lock() const;
+        std::weak_ptr<T>& GetStd();
 
     private:
-        std::weak_ptr<T> ref;
+        std::weak_ptr<T> ptr;
     };
 
-    template <typename T, typename... Args>
-    UniqueRef<T> MakeUnique(Args&&... args);
-
-    template <typename T, typename... Args>
-    SharedRef<T> MakeShared(Args&&... args);
+    template <typename T, typename... Args> UniquePtr<T> MakeUnique(Args&&... args);
+    template <typename T, typename... Args> SharedPtr<T> MakeShared(Args&&... args);
 }
 
 namespace Common {
     template <typename T>
-    UniqueRef<T>::UniqueRef(T* pointer)
-        : ref(pointer)
+    UniquePtr<T>::UniquePtr(T* pointer)
+        : ptr(pointer)
     {
     }
 
     template <typename T>
-    UniqueRef<T>::UniqueRef(std::unique_ptr<T>&& inRef)
-        : ref(std::move(inRef))
+    UniquePtr<T>::UniquePtr(std::unique_ptr<T>&& uniquePtr)
+        : ptr(std::move(uniquePtr))
     {
     }
 
     template <typename T>
-    UniqueRef<T>::UniqueRef(UniqueRef&& other) noexcept
-        : ref(std::move(other.ref))
+    UniquePtr<T>::UniquePtr(UniquePtr&& other) noexcept
+        : ptr(std::move(other.ptr))
     {
     }
 
     template <typename T>
-    UniqueRef<T>::UniqueRef() = default;
+    UniquePtr<T>::UniquePtr() = default;
 
     template <typename T>
-    UniqueRef<T>::~UniqueRef() = default;
+    UniquePtr<T>::~UniquePtr() = default;
 
     template <typename T>
-    UniqueRef<T>& UniqueRef<T>::operator=(T* pointer)
+    UniquePtr<T>& UniquePtr<T>::operator=(T* pointer)
     {
-        ref = std::unique_ptr<T>(pointer);
+        ptr = std::unique_ptr<T>(pointer);
         return *this;
     }
 
     template <typename T>
-    UniqueRef<T>& UniqueRef<T>::operator=(std::unique_ptr<T>&& inRef)
+    UniquePtr<T>& UniquePtr<T>::operator=(std::unique_ptr<T>&& uniquePtr)
     {
-        ref = std::move(inRef);
+        ptr = std::move(uniquePtr);
         return *this;
     }
 
     template <typename T>
-    UniqueRef<T>& UniqueRef<T>::operator=(UniqueRef&& other) noexcept
+    UniquePtr<T>& UniquePtr<T>::operator=(UniquePtr&& other) noexcept
     {
-        ref = std::move(other.ref);
+        ptr = std::move(other.ptr);
         return *this;
     }
 
     template <typename T>
-    T* UniqueRef<T>::operator->() const noexcept
+    T* UniquePtr<T>::operator->() const noexcept
     {
-        return ref.operator->();
+        return ptr.operator->();
     }
 
     template <typename T>
-    T& UniqueRef<T>::operator*() const noexcept
+    T& UniquePtr<T>::operator*() const noexcept
     {
-        return ref.operator*();
+        return ptr.operator*();
     }
 
     template <typename T>
-    bool UniqueRef<T>::operator==(nullptr_t) const noexcept
+    bool UniquePtr<T>::operator==(nullptr_t) const noexcept
     {
-        return ref == nullptr;
+        return ptr == nullptr;
     }
 
     template <typename T>
-    bool UniqueRef<T>::operator!=(nullptr_t) const noexcept
+    bool UniquePtr<T>::operator!=(nullptr_t) const noexcept
     {
-        return ref != nullptr;
+        return ptr != nullptr;
     }
 
     template <typename T>
-    T* UniqueRef<T>::Get() const
+    UniquePtr<T>::operator bool() const noexcept
     {
-        return ref.get();
+        return Valid();
     }
 
     template <typename T>
-    void UniqueRef<T>::Reset(T* pointer)
+    T* UniquePtr<T>::Get() const
     {
-        ref.reset(pointer);
+        return ptr.get();
+    }
+
+    template <typename T>
+    bool UniquePtr<T>::Valid() const
+    {
+        return ptr != nullptr;
+    }
+
+    template <typename T>
+    void UniquePtr<T>::Reset(T* pointer)
+    {
+        ptr.reset(pointer);
+    }
+
+    template <typename T>
+    std::unique_ptr<T>& UniquePtr<T>::GetStd()
+    {
+        return ptr;
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>::SharedRef(std::shared_ptr<T2>& inRef)
-        : ref(inRef)
+    SharedPtr<T>::SharedPtr(std::shared_ptr<T2>& sharedPtr)
+        : ptr(sharedPtr)
     {
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>::SharedRef(std::shared_ptr<T2>&& inRef) noexcept
-        : ref(std::move(inRef))
+    SharedPtr<T>::SharedPtr(std::shared_ptr<T2>&& sharedPtr) noexcept
+        : ptr(std::move(sharedPtr))
     {
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>::SharedRef(std::unique_ptr<T2>&& inRef) noexcept
-        : ref(std::move(inRef))
+    SharedPtr<T>::SharedPtr(std::unique_ptr<T2>&& uniquePtr) noexcept
+        : ptr(std::move(uniquePtr))
     {
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>::SharedRef(UniqueRef<T2>&& inRef) noexcept
-        : ref(std::move(inRef.Get()))
+    SharedPtr<T>::SharedPtr(UniquePtr<T2>&& uniquePtr) noexcept
+        : ptr(std::move(uniquePtr.Get()))
     {
     }
 
     template <typename T>
-    SharedRef<T>::SharedRef(T* pointer)
-        : ref(pointer)
+    SharedPtr<T>::SharedPtr(T* pointer)
+        : ptr(pointer)
     {
     }
 
     template <typename T>
-    SharedRef<T>::SharedRef(const SharedRef& other)
-        : ref(other.ref)
+    SharedPtr<T>::SharedPtr(const SharedPtr& other)
+        : ptr(other.ptr)
     {
     }
 
     template <typename T>
-    SharedRef<T>::SharedRef(SharedRef && other) noexcept
-        : ref(std::move(other.ref))
+    SharedPtr<T>::SharedPtr(SharedPtr && other) noexcept
+        : ptr(std::move(other.ptr))
     {
     }
 
     template <typename T>
-    SharedRef<T>::SharedRef() = default;
+    SharedPtr<T>::SharedPtr() = default;
 
     template <typename T>
-    SharedRef<T>::~SharedRef() = default;
+    SharedPtr<T>::~SharedPtr() = default;
 
     template <typename T>
     template <typename T2>
-    SharedRef<T> & SharedRef<T>::operator=(std::shared_ptr<T2> & inRef)
+    SharedPtr<T> & SharedPtr<T>::operator=(std::shared_ptr<T2> & sharedPtr)
     {
-        ref = inRef;
+        ptr = sharedPtr;
         return *this;
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T> & SharedRef<T>::operator=(std::shared_ptr<T2> && inRef)
+    SharedPtr<T> & SharedPtr<T>::operator=(std::shared_ptr<T2> && sharedPtr)
     {
-        ref = std::move(inRef);
+        ptr = std::move(sharedPtr);
         return *this;
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>& SharedRef<T>::operator=(std::unique_ptr<T2>&& inRef) noexcept
+    SharedPtr<T>& SharedPtr<T>::operator=(std::unique_ptr<T2>&& uniquePtr) noexcept
     {
-        ref = std::move(inRef);
+        ptr = std::move(uniquePtr);
         return *this;
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T>& SharedRef<T>::operator=(UniqueRef<T2>&& inRef) noexcept
+    SharedPtr<T>& SharedPtr<T>::operator=(UniquePtr<T2>&& uniquePtr) noexcept
     {
-        ref = std::move(inRef.Get());
+        ptr = std::move(uniquePtr.Get());
         return *this;
     }
 
     template <typename T>
-    SharedRef<T> & SharedRef<T>::operator=(T* pointer)
+    SharedPtr<T> & SharedPtr<T>::operator=(T* pointer)
     {
-        ref = std::shared_ptr<T>(pointer);
+        ptr = std::shared_ptr<T>(pointer);
         return *this;
     }
 
     template <typename T>
-    SharedRef<T> & SharedRef<T>::operator=(SharedRef & other)
+    SharedPtr<T> & SharedPtr<T>::operator=(SharedPtr& other)
     {
-        ref = other.ref;
+        ptr = other.ptr;
         return *this;
     }
 
     template <typename T>
-    SharedRef<T> & SharedRef<T>::operator=(SharedRef && other) noexcept
+    SharedPtr<T> & SharedPtr<T>::operator=(SharedPtr&& other) noexcept
     {
-        ref = std::move(other.ref);
+        ptr = std::move(other.ptr);
         return *this;
     }
 
     template <typename T>
-    T* SharedRef<T>::operator->() const noexcept
+    T* SharedPtr<T>::operator->() const noexcept
     {
-        return ref.operator->();
+        return ptr.operator->();
     }
 
     template <typename T>
-    T& SharedRef<T>::operator*() const noexcept
+    T& SharedPtr<T>::operator*() const noexcept
     {
-        return ref.operator*();
+        return ptr.operator*();
     }
 
     template <typename T>
-    bool SharedRef<T>::operator==(nullptr_t) const noexcept
+    bool SharedPtr<T>::operator==(nullptr_t) const noexcept
     {
-        return ref == nullptr;
+        return ptr == nullptr;
     }
 
     template <typename T>
-    bool SharedRef<T>::operator!=(nullptr_t) const noexcept
+    bool SharedPtr<T>::operator!=(nullptr_t) const noexcept
     {
-        return ref != nullptr;
+        return ptr != nullptr;
     }
 
     template <typename T>
-    T* SharedRef<T>::Get() const
+    SharedPtr<T>::operator bool() const noexcept
     {
-        return ref.get();
+        return Valid();
     }
 
     template <typename T>
-    void SharedRef<T>::Reset(T* pointer)
+    bool SharedPtr<T>::Valid() const
     {
-        ref.reset(pointer);
+        return ptr != nullptr;
     }
 
     template <typename T>
-    auto SharedRef<T>::RefCount() const
+    T* SharedPtr<T>::Get() const
     {
-        return ref.use_count();
+        return ptr.get();
     }
 
     template <typename T>
-    std::shared_ptr<T> & SharedRef<T>::GetStd()
+    void SharedPtr<T>::Reset(T* pointer)
     {
-        return ref;
+        ptr.reset(pointer);
+    }
+
+    template <typename T>
+    auto SharedPtr<T>::RefCount() const
+    {
+        return ptr.use_count();
+    }
+
+    template <typename T>
+    std::shared_ptr<T> & SharedPtr<T>::GetStd()
+    {
+        return ptr;
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T2> SharedRef<T>::StaticCast()
+    SharedPtr<T2> SharedPtr<T>::StaticCast()
     {
-        return static_pointer_cast<T2, T>(ref);
+        return static_pointer_cast<T2, T>(ptr);
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T2> SharedRef<T>::DynamicCast()
+    SharedPtr<T2> SharedPtr<T>::DynamicCast()
     {
-        return dynamic_pointer_cast<T2, T>(ref);
+        return dynamic_pointer_cast<T2, T>(ptr);
     }
 
     template <typename T>
     template <typename T2>
-    SharedRef<T2> SharedRef<T>::ReinterpretCast()
+    SharedPtr<T2> SharedPtr<T>::ReinterpretCast()
     {
-        return reinterpret_pointer_cast<T2, T>(ref);
+        return reinterpret_pointer_cast<T2, T>(ptr);
     }
 
     template <typename T>
     template <typename T2>
-    WeakRef<T>::WeakRef(SharedRef<T2> & inRef)
-        : ref(inRef.GetStd())
+    WeakPtr<T>::WeakPtr(SharedPtr<T2> & sharedPtr)
+        : ptr(sharedPtr.GetStd())
     {
     }
 
     template <typename T>
-    WeakRef<T>::WeakRef(WeakRef& other)
-        : ref(other.ref)
+    WeakPtr<T>::WeakPtr(WeakPtr& other)
+        : ptr(other.ptr)
     {
     }
 
     template <typename T>
-    WeakRef<T>::WeakRef(WeakRef && other) noexcept
-        : ref(std::move(other.ref))
+    WeakPtr<T>::WeakPtr(WeakPtr && other) noexcept
+        : ptr(std::move(other.ptr))
     {
     }
 
     template <typename T>
-    WeakRef<T>::~WeakRef() = default;
+    WeakPtr<T>::~WeakPtr() = default;
 
     template <typename T>
     template <typename T2>
-    WeakRef<T>& WeakRef<T>::operator=(SharedRef<T2> & inRef)
+    WeakPtr<T>& WeakPtr<T>::operator=(SharedPtr<T2> & sharedPtr)
     {
-        ref = inRef.GetStd();
+        ptr = sharedPtr.GetStd();
         return *this;
     }
 
     template <typename T>
-    WeakRef<T>& WeakRef<T>::operator=(WeakRef & other)
+    WeakPtr<T>& WeakPtr<T>::operator=(WeakPtr & other)
     {
-        ref = other.ref;
+        ptr = other.ptr;
         return *this;
     }
 
     template <typename T>
-    WeakRef<T> & WeakRef<T>::operator=(WeakRef && other) noexcept
+    WeakPtr<T> & WeakPtr<T>::operator=(WeakPtr && other) noexcept
     {
-        ref = std::move(other.ref);
+        ptr = std::move(other.ptr);
         return *this;
     }
 
     template <typename T>
-    void WeakRef<T>::Reset()
+    void WeakPtr<T>::Reset()
+    {
+        ptr.reset();
+    }
+
+    template <typename T>
+    bool WeakPtr<T>::Expired() const
     {
-        ref.reset();
+        return ptr.expired();
     }
 
     template <typename T>
-    bool WeakRef<T>::Expired() const
+    SharedPtr<T> WeakPtr<T>::Lock() const
     {
-        return ref.expired();
+        return ptr.lock();
     }
 
     template <typename T>
-    SharedRef<T> WeakRef<T>::Lock() const
+    std::weak_ptr<T>& WeakPtr<T>::GetStd()
     {
-        return ref.lock();
+        return ptr;
     }
 
     template <typename T, typename... Args>
-    UniqueRef<T> MakeUnique(Args && ... args)
+    UniquePtr<T> MakeUnique(Args && ... args)
     {
-        return Common::UniqueRef<T>(new T(std::forward<Args>(args)...));
+        return Common::UniquePtr<T>(new T(std::forward<Args>(args)...));
     }
 
     template <typename T, typename... Args>
-    SharedRef<T> MakeShared(Args && ... args)
+    SharedPtr<T> MakeShared(Args && ... args)
     {
-        return Common::SharedRef<T>(new T(std::forward<Args>(args)...));
+        return Common::SharedPtr<T>(new T(std::forward<Args>(args)...));
     }
 }
diff --git a/Engine/Source/Common/Src/Concurrent.cpp b/Engine/Source/Common/Src/Concurrent.cpp
index 0a27a2645..34dfbcb70 100644
--- a/Engine/Source/Common/Src/Concurrent.cpp
+++ b/Engine/Source/Common/Src/Concurrent.cpp
@@ -9,6 +9,7 @@
 #endif
 
 #include <Common/Concurrent.h>
+#include <Common/String.h>
 
 namespace Common {
     NamedThread::NamedThread() = default;
diff --git a/Engine/Source/Common/Test/ConcurrentTest.cpp b/Engine/Source/Common/Test/ConcurrentTest.cpp
index f7ef4c1c9..a97df50e5 100644
--- a/Engine/Source/Common/Test/ConcurrentTest.cpp
+++ b/Engine/Source/Common/Test/ConcurrentTest.cpp
@@ -65,6 +65,14 @@ TEST(ConcurrentTest, ThreadPoolTest3)
     ASSERT_EQ(count, 200);
 }
 
+TEST(ConcurrentTest, ThreadPoolExecuteTasksTest)
+{
+    Common::ThreadPool threadPool("TestThreadPool", 4);
+    std::atomic<uint32_t> count = 0;
+    threadPool.ExecuteTasks(64, [&count](size_t i) -> void { ++count; });
+    ASSERT_EQ(count, 64);
+}
+
 TEST(ConcurrentTest, WorkerThread0)
 {
     uint32_t value = 0;
diff --git a/Engine/Source/Common/Test/MemoryTest.cpp b/Engine/Source/Common/Test/MemoryTest.cpp
index 2c0e4c6be..cc975bcb5 100644
--- a/Engine/Source/Common/Test/MemoryTest.cpp
+++ b/Engine/Source/Common/Test/MemoryTest.cpp
@@ -34,18 +34,18 @@ TEST(MemoryTest, UniqueRefTest) // NOLINT
 {
     bool live;
     {
-        const UniqueRef ref = new TestStruct(1, live);
+        const UniquePtr ref = new TestStruct(1, live);
         ASSERT_EQ(live, true);
         ASSERT_EQ(ref->value, 1);
     }
     ASSERT_EQ(live, false);
 
     {
-        UniqueRef ref = new TestStruct(1, live);
+        UniquePtr ref = new TestStruct(1, live);
         ASSERT_EQ(live, true);
         ASSERT_EQ(ref->value, 1);
 
-        UniqueRef<TestStruct> movedRef = std::move(ref);
+        UniquePtr<TestStruct> movedRef = std::move(ref);
         ASSERT_EQ(live, true);
     }
     ASSERT_EQ(live, false);
@@ -55,17 +55,17 @@ TEST(MemoryTest, SharedRefTest) // NOLINT
 {
     bool live;
     {
-        const SharedRef ref1 = new TestStruct(1, live);
+        const SharedPtr ref1 = new TestStruct(1, live);
         ASSERT_EQ(live, true);
         ASSERT_EQ(ref1->value, 1);
         ASSERT_EQ(ref1.RefCount(), 1);
 
-        SharedRef<TestStruct> ref2 = ref1;
+        SharedPtr<TestStruct> ref2 = ref1;
         ASSERT_EQ(live, true);
         ASSERT_EQ(ref2->value, 1);
         ASSERT_EQ(ref2.RefCount(), 2);
 
-        const SharedRef<TestStruct> ref3 = std::move(ref2);
+        const SharedPtr<TestStruct> ref3 = std::move(ref2);
         ASSERT_EQ(live, true);
         ASSERT_EQ(ref3->value, 1);
         ASSERT_EQ(ref1.RefCount(), 2);
@@ -77,12 +77,12 @@ TEST(MemoryTest, SharedRefTest) // NOLINT
 TEST(MemoryTest, WeakRefTest) // NOLINT
 {
     bool live;
-    SharedRef ref = new TestStruct(1, live);
+    SharedPtr ref = new TestStruct(1, live);
     ASSERT_EQ(live, true);
     ASSERT_EQ(ref->value, 1);
     ASSERT_EQ(ref.RefCount(), 1);
 
-    const WeakRef<TestStruct> weakRef = ref;
+    const WeakPtr<TestStruct> weakRef = ref;
     ASSERT_EQ(live, true);
     ASSERT_EQ(weakRef.Expired(), false);
     ASSERT_EQ(ref.RefCount(), 1);
@@ -108,19 +108,19 @@ TEST(MemoryTest, WeakRefTest) // NOLINT
 TEST(MemoryTest, WeakRefDeriveTest) // NOLINT
 {
     bool live;
-    SharedRef ref = new ChildTestStruct(1, 2, live);
+    SharedPtr ref = new ChildTestStruct(1, 2, live);
     ASSERT_EQ(live, true);
     ASSERT_EQ(ref->value, 1);
     ASSERT_EQ(ref->cValue, 2);
     ASSERT_EQ(ref.RefCount(), 1);
 
-    const WeakRef<TestStruct> weakRef = ref;
+    const WeakPtr<TestStruct> weakRef = ref;
     ASSERT_EQ(live, true);
     ASSERT_EQ(weakRef.Expired(), false);
     ASSERT_EQ(ref.RefCount(), 1);
 
     {
-        const SharedRef<ChildTestStruct> lockRef = weakRef.Lock().StaticCast<ChildTestStruct>();
+        const SharedPtr<ChildTestStruct> lockRef = weakRef.Lock().StaticCast<ChildTestStruct>();
         ASSERT_EQ(lockRef != nullptr, true);
         ASSERT_EQ(live, true);
         ASSERT_EQ(lockRef->value, 1);
diff --git a/Engine/Source/Common/Test/SerializationTest.h b/Engine/Source/Common/Test/SerializationTest.h
index 706fe3327..6c86be48f 100644
--- a/Engine/Source/Common/Test/SerializationTest.h
+++ b/Engine/Source/Common/Test/SerializationTest.h
@@ -35,8 +35,8 @@ inline std::string GetEndianString(std::endian e)
 
 template <typename T>
 void PerformTypedSerializationTestWithStream(
-    const std::function<Common::UniqueRef<Common::BinarySerializeStream>()>& createSerializeStream,
-    const std::function<Common::UniqueRef<Common::BinaryDeserializeStream>()>& createDeserializeStream,
+    const std::function<Common::UniquePtr<Common::BinarySerializeStream>()>& createSerializeStream,
+    const std::function<Common::UniquePtr<Common::BinaryDeserializeStream>()>& createDeserializeStream,
     const T& inValue)
 {
     {
@@ -59,14 +59,14 @@ void PerformTypedSerializationTestWithEndian(const T& inValue)
     std::filesystem::create_directories(fileName.parent_path());
 
     PerformTypedSerializationTestWithStream<T>(
-        []() -> Common::UniqueRef<Common::BinarySerializeStream> { return { new Common::BinaryFileSerializeStream<E>(fileName.string()) }; },
-        []() -> Common::UniqueRef<Common::BinaryDeserializeStream> { return { new Common::BinaryFileDeserializeStream<E>(fileName.string()) }; },
+        []() -> Common::UniquePtr<Common::BinarySerializeStream> { return {new Common::BinaryFileSerializeStream<E>(fileName.string()) }; },
+        []() -> Common::UniquePtr<Common::BinaryDeserializeStream> { return {new Common::BinaryFileDeserializeStream<E>(fileName.string()) }; },
         inValue);
 
     std::vector<uint8_t> buffer;
     PerformTypedSerializationTestWithStream<T>(
-        [&]() -> Common::UniqueRef<Common::BinarySerializeStream> { return { new Common::MemorySerializeStream<E>(buffer) }; },
-        [&]() -> Common::UniqueRef<Common::BinaryDeserializeStream> { return { new Common::MemoryDeserializeStream<E>(buffer) }; },
+        [&]() -> Common::UniquePtr<Common::BinarySerializeStream> { return {new Common::MemorySerializeStream<E>(buffer) }; },
+        [&]() -> Common::UniquePtr<Common::BinaryDeserializeStream> { return {new Common::MemoryDeserializeStream<E>(buffer) }; },
         inValue);
 }
 
diff --git a/Engine/Source/Core/Include/Core/Log.h b/Engine/Source/Core/Include/Core/Log.h
index c70a54e45..56f2c89cf 100644
--- a/Engine/Source/Core/Include/Core/Log.h
+++ b/Engine/Source/Core/Include/Core/Log.h
@@ -74,7 +74,7 @@ namespace Core {
         NonMovable(Logger)
 
         void Log(const std::string& inTag, const std::string& inLevel, const std::string& inContent);
-        void Attach(Common::UniqueRef<LogStream>&& inStream);
+        void Attach(Common::UniquePtr<LogStream>&& inStream);
         void Flush();
 
     private:
@@ -83,6 +83,6 @@ namespace Core {
         void LogInternal(const std::string& inString);
 
         float lastFlushTimeSec;
-        std::vector<Common::UniqueRef<LogStream>> streams;
+        std::vector<Common::UniquePtr<LogStream>> streams;
     };
 }
diff --git a/Engine/Source/Core/Src/Log.cpp b/Engine/Source/Core/Src/Log.cpp
index 625e9c8c9..b6c4560eb 100644
--- a/Engine/Source/Core/Src/Log.cpp
+++ b/Engine/Source/Core/Src/Log.cpp
@@ -65,7 +65,7 @@ namespace Core {
         LogInternal(std::format("[{}][{}][{}] {}", time.ToString(), inTag, inLevel, inContent));
     }
 
-    void Logger::Attach(Common::UniqueRef<LogStream>&& inStream)
+    void Logger::Attach(Common::UniquePtr<LogStream>&& inStream)
     {
         streams.emplace_back(std::move(inStream));
     }
diff --git a/Engine/Source/Mirror/Test/AnyTest.cpp b/Engine/Source/Mirror/Test/AnyTest.cpp
index 77ac3c5f5..e7cb229c8 100644
--- a/Engine/Source/Mirror/Test/AnyTest.cpp
+++ b/Engine/Source/Mirror/Test/AnyTest.cpp
@@ -659,7 +659,7 @@ TEST(AnyTest, ConstTryAsTest)
 
 TEST(AnyTest, PolyAsTest)
 {
-    const Common::UniqueRef<AnyBaseClassTest2> v0 = new AnyDerivedClassTest2(1, 2.0f, "3");
+    const Common::UniquePtr<AnyBaseClassTest2> v0 = new AnyDerivedClassTest2(1, 2.0f, "3");
 
     Any a0 = std::ref(*v0);
     const auto& r0 = a0.PolyAs<AnyBaseClassTest2&, AnyDerivedClassTest2&>();
@@ -676,7 +676,7 @@ TEST(AnyTest, PolyAsTest)
 
 TEST(AnyTest, ConstPolyAsTest)
 {
-    const Common::UniqueRef<AnyBaseClassTest2> v0 = new AnyDerivedClassTest2(1, 2.0f, "3");
+    const Common::UniquePtr<AnyBaseClassTest2> v0 = new AnyDerivedClassTest2(1, 2.0f, "3");
 
     const Any a0 = std::ref(*v0);
     const auto& r0 = a0.PolyAs<AnyBaseClassTest2&, AnyDerivedClassTest2&>();
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Buffer.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Buffer.h
index 91765bff7..d386c5bf2 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Buffer.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Buffer.h
@@ -22,7 +22,7 @@ namespace RHI::DirectX12 {
 
         void* Map(MapMode inMapMode, size_t inOffset, size_t inLength) override;
         void UnMap() override;
-        Common::UniqueRef<BufferView> CreateBufferView(const BufferViewCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BufferView> CreateBufferView(const BufferViewCreateInfo& inCreateInfo) override;
 
         ID3D12Resource* GetNative() const;
         DX12Device& GetDevice() const;
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/BufferView.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/BufferView.h
index 11399d3ae..d829ea5f9 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/BufferView.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/BufferView.h
@@ -29,6 +29,6 @@ namespace RHI::DirectX12 {
         void CreateNativeView(const BufferViewCreateInfo& inCreateInfo);
 
         DX12Buffer& buffer;
-        std::variant<Common::UniqueRef<DescriptorAllocation>, D3D12_VERTEX_BUFFER_VIEW, D3D12_INDEX_BUFFER_VIEW> nativeView;
+        std::variant<Common::UniquePtr<DescriptorAllocation>, D3D12_VERTEX_BUFFER_VIEW, D3D12_INDEX_BUFFER_VIEW> nativeView;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandBuffer.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandBuffer.h
index 50e48cf55..dca744d12 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandBuffer.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandBuffer.h
@@ -50,8 +50,8 @@ namespace RHI::DirectX12 {
         static constexpr uint32_t cbvSrvUavHeapCapacity = 10240;
 
         DX12Device& device;
-        Common::UniqueRef<RuntimeDescriptorHeap> samplerHeap;
-        Common::UniqueRef<RuntimeDescriptorHeap> cbvSrvUavHeap;
+        Common::UniquePtr<RuntimeDescriptorHeap> samplerHeap;
+        Common::UniquePtr<RuntimeDescriptorHeap> cbvSrvUavHeap;
     };
 
     class DX12CommandBuffer final : public CommandBuffer {
@@ -60,16 +60,19 @@ namespace RHI::DirectX12 {
         explicit DX12CommandBuffer(DX12Device& inDevice);
         ~DX12CommandBuffer() override;
 
-        Common::UniqueRef<CommandRecorder> Begin() override;
+        Common::UniquePtr<CommandRecorder> Begin() override;
 
-        ID3D12GraphicsCommandList* GetNative() const;
+        ID3D12CommandAllocator* GetNativeAllocator() const;
+        ID3D12GraphicsCommandList* GetNativeCmdList() const;
         RuntimeDescriptorCompact* GetRuntimeDescriptorHeaps() const;
 
     private:
-        void AllocateDX12CommandList(DX12Device& inDevice);
+        void CreateNativeCommandAllocator(DX12Device& inDevice);
+        void CreateNativeCommandList(DX12Device& inDevice);
 
         DX12Device& device;
-        ComPtr<ID3D12GraphicsCommandList> dx12GraphicsCommandList;
-        Common::UniqueRef<RuntimeDescriptorCompact> runtimeDescriptorHeaps;
+        ComPtr<ID3D12CommandAllocator> nativeCommandAllocator;
+        ComPtr<ID3D12GraphicsCommandList> nativeGraphicsCommandList;
+        Common::UniquePtr<RuntimeDescriptorCompact> runtimeDescriptorHeaps;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandRecorder.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandRecorder.h
index ed085b0d4..1d9d94000 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandRecorder.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/CommandRecorder.h
@@ -20,9 +20,9 @@ namespace RHI::DirectX12 {
         ~DX12CommandRecorder() override;
 
         void ResourceBarrier(const Barrier& inBarrier) override;
-        Common::UniqueRef<CopyPassCommandRecorder> BeginCopyPass() override;
-        Common::UniqueRef<ComputePassCommandRecorder> BeginComputePass() override;
-        Common::UniqueRef<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& inBeginInfo) override;
+        Common::UniquePtr<CopyPassCommandRecorder> BeginCopyPass() override;
+        Common::UniquePtr<ComputePassCommandRecorder> BeginComputePass() override;
+        Common::UniquePtr<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& inBeginInfo) override;
         void End() override;
 
     private:
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Device.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Device.h
index 7210fe991..02b06fc87 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Device.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Device.h
@@ -43,7 +43,7 @@ namespace RHI::DirectX12 {
         DescriptorHeapNode(ComPtr<ID3D12DescriptorHeap>&& inHeap, uint32_t inDescriptorSize, uint32_t inCapacity);
 
         bool HasFreeSlot() const;
-        Common::UniqueRef<DescriptorAllocation> Allocate();
+        Common::UniquePtr<DescriptorAllocation> Allocate();
         void Free(uint32_t slot);
 
     private:
@@ -57,7 +57,7 @@ namespace RHI::DirectX12 {
     class DescriptorPool {
     public:
         DescriptorPool(DX12Device& inDevice, D3D12_DESCRIPTOR_HEAP_TYPE inNativeHeapType, uint32_t inDescriptorSize, uint32_t inCapacity);
-        Common::UniqueRef<DescriptorAllocation> Allocate();
+        Common::UniquePtr<DescriptorAllocation> Allocate();
 
     private:
         DX12Device& device;
@@ -75,36 +75,34 @@ namespace RHI::DirectX12 {
 
         size_t GetQueueNum(QueueType inType) override;
         Queue* GetQueue(QueueType inType, size_t inIndex) override;
-        Common::UniqueRef<Surface> CreateSurface(const SurfaceCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<SwapChain> CreateSwapChain(const SwapChainCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Buffer> CreateBuffer(const BufferCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Texture> CreateTexture(const TextureCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Sampler> CreateSampler(const SamplerCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<BindGroup> CreateBindGroup(const BindGroupCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<CommandBuffer> CreateCommandBuffer() override;
-        Common::UniqueRef<Fence> CreateFence(bool inInitAsSignaled) override;
-        Common::UniqueRef<Semaphore> CreateSemaphore() override;
+        Common::UniquePtr<Surface> CreateSurface(const SurfaceCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<SwapChain> CreateSwapChain(const SwapChainCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Buffer> CreateBuffer(const BufferCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Texture> CreateTexture(const TextureCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BindGroup> CreateBindGroup(const BindGroupCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<CommandBuffer> CreateCommandBuffer() override;
+        Common::UniquePtr<Fence> CreateFence(bool inInitAsSignaled) override;
+        Common::UniquePtr<Semaphore> CreateSemaphore() override;
 
         bool CheckSwapChainFormatSupport(Surface* inSurface, PixelFormat inFormat) override;
         TextureSubResourceCopyFootprint GetTextureSubResourceCopyFootprint(const Texture& texture, const TextureSubResourceInfo& subResourceInfo) override;
 
         DX12Gpu& GetGpu() const;
         ID3D12Device* GetNative() const;
-        ID3D12CommandAllocator* GetNativeCmdAllocator() const;
-        Common::UniqueRef<DescriptorAllocation> AllocateRtvDescriptor() const;
-        Common::UniqueRef<DescriptorAllocation> AllocateCbvSrvUavDescriptor() const;
-        Common::UniqueRef<DescriptorAllocation> AllocateSamplerDescriptor() const;
-        Common::UniqueRef<DescriptorAllocation> AllocateDsvDescriptor() const;
+        Common::UniquePtr<DescriptorAllocation> AllocateRtvDescriptor() const;
+        Common::UniquePtr<DescriptorAllocation> AllocateCbvSrvUavDescriptor() const;
+        Common::UniquePtr<DescriptorAllocation> AllocateSamplerDescriptor() const;
+        Common::UniquePtr<DescriptorAllocation> AllocateDsvDescriptor() const;
 
     private:
         void CreateNativeDevice();
         void CreateNativeQueues(const DeviceCreateInfo& inCreateInfo);
-        void CreateNativeCmdAllocator();
         void QueryNativeDescriptorSize();
         void CreateDescriptorPools();
 #if BUILD_CONFIG_DEBUG
@@ -113,16 +111,15 @@ namespace RHI::DirectX12 {
 #endif
 
         DX12Gpu& gpu;
-        std::unordered_map<QueueType, std::vector<Common::UniqueRef<DX12Queue>>> queues;
+        std::unordered_map<QueueType, std::vector<Common::UniquePtr<DX12Queue>>> queues;
         uint32_t nativeRtvDescriptorSize;
         uint32_t nativeCbvSrvUavDescriptorSize;
         uint32_t nativeSamplerDescriptorSize;
         uint32_t nativeDsvDescriptorSize;
-        Common::UniqueRef<DescriptorPool> rtvDescriptorPool;
-        Common::UniqueRef<DescriptorPool> cbvSrvUavDescriptorPool;
-        Common::UniqueRef<DescriptorPool> samplerDescriptorPool;
-        Common::UniqueRef<DescriptorPool> dsvDescriptorPool;
+        Common::UniquePtr<DescriptorPool> rtvDescriptorPool;
+        Common::UniquePtr<DescriptorPool> cbvSrvUavDescriptorPool;
+        Common::UniquePtr<DescriptorPool> samplerDescriptorPool;
+        Common::UniquePtr<DescriptorPool> dsvDescriptorPool;
         ComPtr<ID3D12Device> nativeDevice;
-        ComPtr<ID3D12CommandAllocator> nativeCmdAllocator;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Gpu.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Gpu.h
index e3f411d74..ff9d4fd5d 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Gpu.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Gpu.h
@@ -21,7 +21,7 @@ namespace RHI::DirectX12 {
         ~DX12Gpu() override;
 
         GpuProperty GetProperty() override;
-        Common::UniqueRef<Device> RequestDevice(const DeviceCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Device> RequestDevice(const DeviceCreateInfo& inCreateInfo) override;
 
         DX12Instance& GetInstance() const;
         IDXGIAdapter1* GetNative() const;
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Instance.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Instance.h
index fa1105fb2..224c232a5 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Instance.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Instance.h
@@ -55,7 +55,7 @@ namespace RHI::DirectX12 {
 #endif
 
         ComPtr<IDXGIFactory4> nativeFactory;
-        std::vector<Common::UniqueRef<DX12Gpu>> gpus;
+        std::vector<Common::UniquePtr<DX12Gpu>> gpus;
 #if BUILD_CONFIG_DEBUG
         void* nativeExceptionHandler;
         std::unordered_map<const DX12Device*, NativeDebugLayerExceptionHandler> nativeDebugLayerExceptionHandlers;
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Sampler.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Sampler.h
index b8b6b4e2a..df6a03cfe 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Sampler.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Sampler.h
@@ -24,6 +24,6 @@ namespace RHI::DirectX12 {
     private:
         void CreateDX12Descriptor(DX12Device& inDevice, const SamplerCreateInfo& inCreateInfo);
 
-        Common::UniqueRef<DescriptorAllocation> descriptorAllocation;
+        Common::UniquePtr<DescriptorAllocation> descriptorAllocation;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/SwapChain.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/SwapChain.h
index 209a937bb..eb2a20d23 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/SwapChain.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/SwapChain.h
@@ -34,6 +34,6 @@ namespace RHI::DirectX12 {
         uint8_t textureNum;
         PresentMode presentMode;
         ComPtr<IDXGISwapChain3> nativeSwapChain;
-        std::vector<Common::UniqueRef<Texture>> textures;
+        std::vector<Common::UniquePtr<Texture>> textures;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Texture.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Texture.h
index b0597bd8b..1e00c4a98 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Texture.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/Texture.h
@@ -19,7 +19,7 @@ namespace RHI::DirectX12 {
         DX12Texture(DX12Device& inDevice, const TextureCreateInfo& inCreateInfo, ComPtr<ID3D12Resource>&& nativeResource);
         ~DX12Texture() override;
 
-        Common::UniqueRef<TextureView> CreateTextureView(const TextureViewCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<TextureView> CreateTextureView(const TextureViewCreateInfo& inCreateInfo) override;
 
         ID3D12Resource* GetNative() const;
 
diff --git a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/TextureView.h b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/TextureView.h
index b05cce5d8..79eb1c968 100644
--- a/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/TextureView.h
+++ b/Engine/Source/RHI-DirectX12/Include/RHI/DirectX12/TextureView.h
@@ -26,6 +26,6 @@ namespace RHI::DirectX12 {
         void CreateNativeDescriptor(DX12Device& inDevice, const TextureViewCreateInfo& inCreateInfo);
 
         DX12Texture& texture;
-        Common::UniqueRef<DescriptorAllocation> descriptorAllocation;
+        Common::UniquePtr<DescriptorAllocation> descriptorAllocation;
     };
 }
diff --git a/Engine/Source/RHI-DirectX12/Src/Buffer.cpp b/Engine/Source/RHI-DirectX12/Src/Buffer.cpp
index 186891480..ecadb4c21 100644
--- a/Engine/Source/RHI-DirectX12/Src/Buffer.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/Buffer.cpp
@@ -88,9 +88,9 @@ namespace RHI::DirectX12 {
         nativeResource->Unmap(0, nullptr);
     }
 
-    Common::UniqueRef<BufferView> DX12Buffer::CreateBufferView(const BufferViewCreateInfo& inCreateInfo)
+    Common::UniquePtr<BufferView> DX12Buffer::CreateBufferView(const BufferViewCreateInfo& inCreateInfo)
     {
-        return Common::UniqueRef<BufferView>(new DX12BufferView(*this, inCreateInfo));
+        return Common::UniquePtr<BufferView>(new DX12BufferView(*this, inCreateInfo));
     }
 
     ID3D12Resource* DX12Buffer::GetNative() const
diff --git a/Engine/Source/RHI-DirectX12/Src/BufferView.cpp b/Engine/Source/RHI-DirectX12/Src/BufferView.cpp
index 1b3569b13..9e1a0fe45 100644
--- a/Engine/Source/RHI-DirectX12/Src/BufferView.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/BufferView.cpp
@@ -20,7 +20,7 @@ namespace RHI::DirectX12 {
 
     CD3DX12_CPU_DESCRIPTOR_HANDLE DX12BufferView::GetNativeCpuDescriptorHandle() const
     {
-        return std::get<Common::UniqueRef<DescriptorAllocation>>(nativeView)->GetCpuHandle();
+        return std::get<Common::UniquePtr<DescriptorAllocation>>(nativeView)->GetCpuHandle();
     }
 
     const D3D12_VERTEX_BUFFER_VIEW& DX12BufferView::GetNativeVertexBufferView() const
@@ -45,7 +45,7 @@ namespace RHI::DirectX12 {
             desc.SizeInBytes = Common::AlignUp<D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT>(inCreateInfo.size);
 
             nativeView = buffer.GetDevice().AllocateCbvSrvUavDescriptor();
-            buffer.GetDevice().GetNative()->CreateConstantBufferView(&desc, std::get<Common::UniqueRef<DescriptorAllocation>>(nativeView)->GetCpuHandle());
+            buffer.GetDevice().GetNative()->CreateConstantBufferView(&desc, std::get<Common::UniquePtr<DescriptorAllocation>>(nativeView)->GetCpuHandle());
         } else if (inCreateInfo.type == BufferViewType::storageBinding) {
             Assert((bufferUsages & BufferUsageBits::storage) != 0);
             auto storageViewInfo = std::get<StorageBufferViewInfo>(inCreateInfo.extend);
@@ -59,7 +59,7 @@ namespace RHI::DirectX12 {
             desc.Buffer.StructureByteStride = storageViewInfo.stride;
 
             nativeView = buffer.GetDevice().AllocateCbvSrvUavDescriptor();
-            buffer.GetDevice().GetNative()->CreateShaderResourceView(buffer.GetNative(), &desc, std::get<Common::UniqueRef<DescriptorAllocation>>(nativeView)->GetCpuHandle());
+            buffer.GetDevice().GetNative()->CreateShaderResourceView(buffer.GetNative(), &desc, std::get<Common::UniquePtr<DescriptorAllocation>>(nativeView)->GetCpuHandle());
         } else if (inCreateInfo.type == BufferViewType::rwStorageBinding) {
             Assert((bufferUsages & BufferUsageBits::rwStorage) != 0);
             auto storageViewInfo = std::get<StorageBufferViewInfo>(inCreateInfo.extend);
@@ -73,7 +73,7 @@ namespace RHI::DirectX12 {
             desc.Buffer.StructureByteStride = storageViewInfo.stride;
 
             nativeView = buffer.GetDevice().AllocateCbvSrvUavDescriptor();
-            buffer.GetDevice().GetNative()->CreateUnorderedAccessView(buffer.GetNative(), nullptr, &desc, std::get<Common::UniqueRef<DescriptorAllocation>>(nativeView)->GetCpuHandle());
+            buffer.GetDevice().GetNative()->CreateUnorderedAccessView(buffer.GetNative(), nullptr, &desc, std::get<Common::UniquePtr<DescriptorAllocation>>(nativeView)->GetCpuHandle());
         } else if (inCreateInfo.type == BufferViewType::vertex) {
             Assert((bufferUsages & BufferUsageBits::vertex) != 0);
 
diff --git a/Engine/Source/RHI-DirectX12/Src/CommandBuffer.cpp b/Engine/Source/RHI-DirectX12/Src/CommandBuffer.cpp
index 6f54645de..351e4628b 100644
--- a/Engine/Source/RHI-DirectX12/Src/CommandBuffer.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/CommandBuffer.cpp
@@ -85,20 +85,26 @@ namespace RHI::DirectX12 {
     DX12CommandBuffer::DX12CommandBuffer(DX12Device& inDevice)
         : device(inDevice)
     {
-        AllocateDX12CommandList(inDevice);
+        CreateNativeCommandAllocator(inDevice);
+        CreateNativeCommandList(inDevice);
         runtimeDescriptorHeaps = Common::MakeUnique<RuntimeDescriptorCompact>(inDevice);
     }
 
     DX12CommandBuffer::~DX12CommandBuffer() = default;
 
-    Common::UniqueRef<CommandRecorder> DX12CommandBuffer::Begin()
+    Common::UniquePtr<CommandRecorder> DX12CommandBuffer::Begin()
     {
-        return Common::UniqueRef<CommandRecorder>(new DX12CommandRecorder(device, *this));
+        return Common::UniquePtr<CommandRecorder>(new DX12CommandRecorder(device, *this));
     }
 
-    ID3D12GraphicsCommandList* DX12CommandBuffer::GetNative() const
+    ID3D12CommandAllocator* DX12CommandBuffer::GetNativeAllocator() const
     {
-        return dx12GraphicsCommandList.Get();
+        return nativeCommandAllocator.Get();
+    }
+
+    ID3D12GraphicsCommandList* DX12CommandBuffer::GetNativeCmdList() const
+    {
+        return nativeGraphicsCommandList.Get();
     }
 
     RuntimeDescriptorCompact* DX12CommandBuffer::GetRuntimeDescriptorHeaps() const
@@ -106,9 +112,14 @@ namespace RHI::DirectX12 {
         return runtimeDescriptorHeaps.Get();
     }
 
-    void DX12CommandBuffer::AllocateDX12CommandList(DX12Device& inDevice)
+    void DX12CommandBuffer::CreateNativeCommandAllocator(DX12Device& inDevice)
+    {
+        Assert(SUCCEEDED(inDevice.GetNative()->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&nativeCommandAllocator))));
+    }
+
+    void DX12CommandBuffer::CreateNativeCommandList(DX12Device& inDevice)
     {
-        Assert(SUCCEEDED(inDevice.GetNative()->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, inDevice.GetNativeCmdAllocator(), nullptr, IID_PPV_ARGS(&dx12GraphicsCommandList))));
-        Assert(SUCCEEDED(dx12GraphicsCommandList->Close()));
+        Assert(SUCCEEDED(inDevice.GetNative()->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, nativeCommandAllocator.Get(), nullptr, IID_PPV_ARGS(&nativeGraphicsCommandList))));
+        Assert(SUCCEEDED(nativeGraphicsCommandList->Close()));
     }
 }
diff --git a/Engine/Source/RHI-DirectX12/Src/CommandRecorder.cpp b/Engine/Source/RHI-DirectX12/Src/CommandRecorder.cpp
index f7b6c06a5..705ddafff 100644
--- a/Engine/Source/RHI-DirectX12/Src/CommandRecorder.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/CommandRecorder.cpp
@@ -91,7 +91,7 @@ namespace RHI::DirectX12 {
         const auto* srcBuffer = static_cast<DX12Buffer*>(src);
         const auto* dstBuffer = static_cast<DX12Buffer*>(dst);
 
-        commandBuffer.GetNative()->CopyBufferRegion(
+        commandBuffer.GetNativeCmdList()->CopyBufferRegion(
             dstBuffer->GetNative(), copyInfo.dstOffset,
             srcBuffer->GetNative(), copyInfo.srcOffset,
             copyInfo.copySize);
@@ -106,7 +106,7 @@ namespace RHI::DirectX12 {
         const CD3DX12_TEXTURE_COPY_LOCATION dstCopyRegion = GetNativeTextureCopyLocation(*dstTexture, copyInfo.textureSubResource);
         const D3D12_BOX srcBox = GetNativeBox(Common::UVec3Consts::zero, copyInfo.copyRegion);
 
-        commandBuffer.GetNative()->CopyTextureRegion(
+        commandBuffer.GetNativeCmdList()->CopyTextureRegion(
             &dstCopyRegion,
             copyInfo.textureOrigin.x,
             copyInfo.textureOrigin.y,
@@ -124,7 +124,7 @@ namespace RHI::DirectX12 {
         const CD3DX12_TEXTURE_COPY_LOCATION dstCopyRegion = GetNativeBufferCopyLocationFromTextureLayout(device, *dstBuffer, *srcTexture, copyInfo);
         const D3D12_BOX srcBox = GetNativeBox(copyInfo.textureOrigin, copyInfo.copyRegion);
 
-        commandBuffer.GetNative()->CopyTextureRegion(
+        commandBuffer.GetNativeCmdList()->CopyTextureRegion(
             &dstCopyRegion,
             0, 0, 0,
             &srcCopyRegion,
@@ -140,7 +140,7 @@ namespace RHI::DirectX12 {
         const CD3DX12_TEXTURE_COPY_LOCATION dstCopyRegion = GetNativeTextureCopyLocation(*dstTexture, copyInfo.dstSubResource);
         const D3D12_BOX srcBox = GetNativeBox(copyInfo.srcOrigin, copyInfo.copyRegion);
 
-        commandBuffer.GetNative()->CopyTextureRegion(
+        commandBuffer.GetNativeCmdList()->CopyTextureRegion(
             &dstCopyRegion,
             copyInfo.dstOrigin.x,
             copyInfo.dstOrigin.y,
@@ -173,8 +173,8 @@ namespace RHI::DirectX12 {
         computePipeline = static_cast<DX12ComputePipeline*>(inPipeline);
         Assert(computePipeline);
 
-        commandBuffer.GetNative()->SetPipelineState(computePipeline->GetNative());
-        commandBuffer.GetNative()->SetComputeRootSignature(computePipeline->GetPipelineLayout().GetNative());
+        commandBuffer.GetNativeCmdList()->SetPipelineState(computePipeline->GetNative());
+        commandBuffer.GetNativeCmdList()->SetComputeRootSignature(computePipeline->GetPipelineLayout().GetNative());
     }
 
     void DX12ComputePassCommandRecorder::SetBindGroup(const uint8_t inLayoutIndex, BindGroup* inBindGroup)
@@ -192,13 +192,13 @@ namespace RHI::DirectX12 {
             if (!t.has_value()) {
                 return;
             }
-            commandBuffer.GetNative()->SetComputeRootDescriptorTable(t.value().second, commandBuffer.GetRuntimeDescriptorHeaps()->NewGpuDescriptorHandle(hlslBinding.rangeType, cpuDescriptorHandle));
+            commandBuffer.GetNativeCmdList()->SetComputeRootDescriptorTable(t.value().second, commandBuffer.GetRuntimeDescriptorHeaps()->NewGpuDescriptorHandle(hlslBinding.rangeType, cpuDescriptorHandle));
         }
     }
 
     void DX12ComputePassCommandRecorder::Dispatch(const size_t inGroupCountX, const size_t inGroupCountY, const size_t inGroupCountZ)
     {
-        commandBuffer.GetNative()->Dispatch(inGroupCountX, inGroupCountY, inGroupCountZ);
+        commandBuffer.GetNativeCmdList()->Dispatch(inGroupCountX, inGroupCountY, inGroupCountZ);
     }
 
     void DX12ComputePassCommandRecorder::EndPass()
@@ -224,7 +224,7 @@ namespace RHI::DirectX12 {
             Assert(view);
             dsvHandle = view->GetNativeCpuDescriptorHandle();
         }
-        inCmdBuffer.GetNative()->OMSetRenderTargets(rtvHandles.size(), rtvHandles.data(), false, dsvHandle.has_value() ? &dsvHandle.value() : nullptr);
+        inCmdBuffer.GetNativeCmdList()->OMSetRenderTargets(rtvHandles.size(), rtvHandles.data(), false, dsvHandle.has_value() ? &dsvHandle.value() : nullptr);
 
         // clear render targets
         for (auto i = 0; i < rtvHandles.size(); i++) {
@@ -233,14 +233,14 @@ namespace RHI::DirectX12 {
                 continue;
             }
             const auto* clearValue = reinterpret_cast<const float*>(&colorAttachment.clearValue);
-            inCmdBuffer.GetNative()->ClearRenderTargetView(rtvHandles[i], clearValue, 0, nullptr);
+            inCmdBuffer.GetNativeCmdList()->ClearRenderTargetView(rtvHandles[i], clearValue, 0, nullptr);
         }
         if (dsvHandle.has_value()) {
             const auto& depthStencilAttachment = *inBeginInfo.depthStencilAttachment;
             if (depthStencilAttachment.depthLoadOp != LoadOp::clear && depthStencilAttachment.stencilLoadOp != LoadOp::clear) {
                 return;
             }
-            inCmdBuffer.GetNative()->ClearDepthStencilView(dsvHandle.value(), GetDX12ClearFlags(depthStencilAttachment), depthStencilAttachment.depthClearValue, depthStencilAttachment.stencilClearValue, 0, nullptr);
+            inCmdBuffer.GetNativeCmdList()->ClearDepthStencilView(dsvHandle.value(), GetDX12ClearFlags(depthStencilAttachment), depthStencilAttachment.depthClearValue, depthStencilAttachment.stencilClearValue, 0, nullptr);
         }
     }
 
@@ -256,8 +256,8 @@ namespace RHI::DirectX12 {
         rasterPipeline = static_cast<DX12RasterPipeline*>(inPipeline);
         Assert(rasterPipeline);
 
-        commandBuffer.GetNative()->SetPipelineState(rasterPipeline->GetNative());
-        commandBuffer.GetNative()->SetGraphicsRootSignature(rasterPipeline->GetPipelineLayout().GetNative());
+        commandBuffer.GetNativeCmdList()->SetPipelineState(rasterPipeline->GetNative());
+        commandBuffer.GetNativeCmdList()->SetGraphicsRootSignature(rasterPipeline->GetPipelineLayout().GetNative());
     }
 
     void DX12RasterPassCommandRecorder::SetBindGroup(const uint8_t inLayoutIndex, BindGroup* inBindGroup)
@@ -275,58 +275,58 @@ namespace RHI::DirectX12 {
             if (!t.has_value()) {
                 return;
             }
-            commandBuffer.GetNative()->SetGraphicsRootDescriptorTable(t.value().second, commandBuffer.GetRuntimeDescriptorHeaps()->NewGpuDescriptorHandle(hlslBinding.rangeType, cpuDescriptorHandle));
+            commandBuffer.GetNativeCmdList()->SetGraphicsRootDescriptorTable(t.value().second, commandBuffer.GetRuntimeDescriptorHeaps()->NewGpuDescriptorHandle(hlslBinding.rangeType, cpuDescriptorHandle));
         }
     }
 
     void DX12RasterPassCommandRecorder::SetIndexBuffer(BufferView* inBufferView)
     {
         const auto* bufferView = static_cast<DX12BufferView*>(inBufferView);
-        commandBuffer.GetNative()->IASetIndexBuffer(&bufferView->GetNativeIndexBufferView());
+        commandBuffer.GetNativeCmdList()->IASetIndexBuffer(&bufferView->GetNativeIndexBufferView());
     }
 
     void DX12RasterPassCommandRecorder::SetVertexBuffer(const size_t inSlot, BufferView* inBufferView)
     {
         const auto* bufferView = static_cast<DX12BufferView*>(inBufferView);
-        commandBuffer.GetNative()->IASetVertexBuffers(inSlot, 1, &bufferView->GetNativeVertexBufferView());
+        commandBuffer.GetNativeCmdList()->IASetVertexBuffers(inSlot, 1, &bufferView->GetNativeVertexBufferView());
     }
 
     void DX12RasterPassCommandRecorder::Draw(const size_t inVertexCount, const size_t inInstanceCount, const size_t inFirstVertex, const size_t inFirstInstance)
     {
-        commandBuffer.GetNative()->DrawInstanced(inVertexCount, inInstanceCount, inFirstVertex, inFirstInstance);
+        commandBuffer.GetNativeCmdList()->DrawInstanced(inVertexCount, inInstanceCount, inFirstVertex, inFirstInstance);
     }
 
     void DX12RasterPassCommandRecorder::DrawIndexed(const size_t inIndexCount, const size_t inInstanceCount, const size_t inFirstIndex, const size_t inBaseVertex, const size_t inFirstInstance)
     {
-        commandBuffer.GetNative()->DrawIndexedInstanced(inIndexCount, inInstanceCount, inFirstIndex, inBaseVertex, inFirstInstance);
+        commandBuffer.GetNativeCmdList()->DrawIndexedInstanced(inIndexCount, inInstanceCount, inFirstIndex, inBaseVertex, inFirstInstance);
     }
 
     void DX12RasterPassCommandRecorder::SetViewport(const float inX, const float inY, const float inWidth, const float inHeight, const float inMinDepth, const float inMaxDepth)
     {
         // (x, y) = topLeft
         const CD3DX12_VIEWPORT viewport(inX, inY, inWidth, inHeight, inMinDepth, inMaxDepth);
-        commandBuffer.GetNative()->RSSetViewports(1, &viewport);
+        commandBuffer.GetNativeCmdList()->RSSetViewports(1, &viewport);
     }
 
     void DX12RasterPassCommandRecorder::SetScissor(uint32_t inLeft, uint32_t inTop, uint32_t inRight, uint32_t inBottom)
     {
         const CD3DX12_RECT scissor(inLeft, inTop, inRight, inBottom);
-        commandBuffer.GetNative()->RSSetScissorRects(1, &scissor);
+        commandBuffer.GetNativeCmdList()->RSSetScissorRects(1, &scissor);
     }
 
     void DX12RasterPassCommandRecorder::SetBlendConstant(const float* inConstants)
     {
-        commandBuffer.GetNative()->OMSetBlendFactor(inConstants);
+        commandBuffer.GetNativeCmdList()->OMSetBlendFactor(inConstants);
     }
 
     void DX12RasterPassCommandRecorder::SetPrimitiveTopology(PrimitiveTopology inPrimitiveTopology)
     {
-        commandBuffer.GetNative()->IASetPrimitiveTopology(EnumCast<PrimitiveTopology, D3D_PRIMITIVE_TOPOLOGY>(inPrimitiveTopology));
+        commandBuffer.GetNativeCmdList()->IASetPrimitiveTopology(EnumCast<PrimitiveTopology, D3D_PRIMITIVE_TOPOLOGY>(inPrimitiveTopology));
     }
 
     void DX12RasterPassCommandRecorder::SetStencilReference(uint32_t inReference)
     {
-        commandBuffer.GetNative()->OMSetStencilRef(inReference);
+        commandBuffer.GetNativeCmdList()->OMSetStencilRef(inReference);
     }
 
     void DX12RasterPassCommandRecorder::EndPass()
@@ -337,11 +337,15 @@ namespace RHI::DirectX12 {
         : device(inDevice)
         , commandBuffer(inCmdBuffer)
     {
-        Assert(SUCCEEDED(inCmdBuffer.GetNative()->Reset(inDevice.GetNativeCmdAllocator(), nullptr)));
+        auto* nativeCmdAllocator = inCmdBuffer.GetNativeAllocator();
+        auto* nativeCmdList = inCmdBuffer.GetNativeCmdList();
+        Assert(nativeCmdAllocator != nullptr && nativeCmdList != nullptr);
+        Assert(SUCCEEDED(nativeCmdAllocator->Reset()));
+        Assert(SUCCEEDED(nativeCmdList->Reset(nativeCmdAllocator, nullptr)));
 
         inCmdBuffer.GetRuntimeDescriptorHeaps()->ResetUsed();
         const auto activeHeap = inCmdBuffer.GetRuntimeDescriptorHeaps()->GetNative();
-        inCmdBuffer.GetNative()->SetDescriptorHeaps(activeHeap.size(), activeHeap.data());
+        nativeCmdList->SetDescriptorHeaps(activeHeap.size(), activeHeap.data());
     }
 
     DX12CommandRecorder::~DX12CommandRecorder() = default;
@@ -366,26 +370,26 @@ namespace RHI::DirectX12 {
         }
 
         const CD3DX12_RESOURCE_BARRIER resourceBarrier = CD3DX12_RESOURCE_BARRIER::Transition(resource, beforeState, afterState);
-        commandBuffer.GetNative()->ResourceBarrier(1, &resourceBarrier);
+        commandBuffer.GetNativeCmdList()->ResourceBarrier(1, &resourceBarrier);
     }
 
-    Common::UniqueRef<CopyPassCommandRecorder> DX12CommandRecorder::BeginCopyPass()
+    Common::UniquePtr<CopyPassCommandRecorder> DX12CommandRecorder::BeginCopyPass()
     {
-        return Common::UniqueRef<CopyPassCommandRecorder>(new DX12CopyPassCommandRecorder(device, *this, commandBuffer));
+        return Common::UniquePtr<CopyPassCommandRecorder>(new DX12CopyPassCommandRecorder(device, *this, commandBuffer));
     }
 
-    Common::UniqueRef<ComputePassCommandRecorder> DX12CommandRecorder::BeginComputePass()
+    Common::UniquePtr<ComputePassCommandRecorder> DX12CommandRecorder::BeginComputePass()
     {
-        return Common::UniqueRef<ComputePassCommandRecorder>(new DX12ComputePassCommandRecorder(device, *this, commandBuffer));
+        return Common::UniquePtr<ComputePassCommandRecorder>(new DX12ComputePassCommandRecorder(device, *this, commandBuffer));
     }
 
-    Common::UniqueRef<RasterPassCommandRecorder> DX12CommandRecorder::BeginRasterPass(const RasterPassBeginInfo& inBeginInfo)
+    Common::UniquePtr<RasterPassCommandRecorder> DX12CommandRecorder::BeginRasterPass(const RasterPassBeginInfo& inBeginInfo)
     {
-        return Common::UniqueRef<RasterPassCommandRecorder>(new DX12RasterPassCommandRecorder(device, *this, commandBuffer, inBeginInfo));
+        return Common::UniquePtr<RasterPassCommandRecorder>(new DX12RasterPassCommandRecorder(device, *this, commandBuffer, inBeginInfo));
     }
 
     void DX12CommandRecorder::End()
     {
-        Assert(SUCCEEDED(commandBuffer.GetNative()->Close()));
+        Assert(SUCCEEDED(commandBuffer.GetNativeCmdList()->Close()));
     }
 }
diff --git a/Engine/Source/RHI-DirectX12/Src/Device.cpp b/Engine/Source/RHI-DirectX12/Src/Device.cpp
index 76a308c8b..953b76715 100644
--- a/Engine/Source/RHI-DirectX12/Src/Device.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/Device.cpp
@@ -64,7 +64,7 @@ namespace RHI::DirectX12 {
         return free > 0;
     }
 
-    Common::UniqueRef<DescriptorAllocation> DescriptorHeapNode::Allocate()
+    Common::UniquePtr<DescriptorAllocation> DescriptorHeapNode::Allocate()
     {
         Assert(HasFreeSlot());
 
@@ -117,7 +117,7 @@ namespace RHI::DirectX12 {
     {
     }
 
-    Common::UniqueRef<DescriptorAllocation> DescriptorPool::Allocate()
+    Common::UniquePtr<DescriptorAllocation> DescriptorPool::Allocate()
     {
         for (auto& node : heapNodes) {
             if (node.HasFreeSlot()) {
@@ -147,7 +147,6 @@ namespace RHI::DirectX12 {
     {
         CreateNativeDevice();
         CreateNativeQueues(inCreateInfo);
-        CreateNativeCmdAllocator();
         QueryNativeDescriptorSize();
         CreateDescriptorPools();
 #if BUILD_CONFIG_DEBUG
@@ -174,77 +173,72 @@ namespace RHI::DirectX12 {
         return queueArray[inIndex].Get();
     }
 
-    Common::UniqueRef<Surface> DX12Device::CreateSurface(const SurfaceCreateInfo& inCreateInfo)
+    Common::UniquePtr<Surface> DX12Device::CreateSurface(const SurfaceCreateInfo& inCreateInfo)
     {
         return { new DX12Surface(inCreateInfo) };
     }
 
-    Common::UniqueRef<SwapChain> DX12Device::CreateSwapChain(const SwapChainCreateInfo& inCreateInfo)
+    Common::UniquePtr<SwapChain> DX12Device::CreateSwapChain(const SwapChainCreateInfo& inCreateInfo)
     {
         return { new DX12SwapChain(*this, inCreateInfo) };
     }
 
-    ID3D12CommandAllocator* DX12Device::GetNativeCmdAllocator() const
-    {
-        return nativeCmdAllocator.Get();
-    }
-
-    Common::UniqueRef<Buffer> DX12Device::CreateBuffer(const BufferCreateInfo& inCreateInfo)
+    Common::UniquePtr<Buffer> DX12Device::CreateBuffer(const BufferCreateInfo& inCreateInfo)
     {
         return { new DX12Buffer(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<Texture> DX12Device::CreateTexture(const TextureCreateInfo& inCreateInfo)
+    Common::UniquePtr<Texture> DX12Device::CreateTexture(const TextureCreateInfo& inCreateInfo)
     {
         return { new DX12Texture(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<Sampler> DX12Device::CreateSampler(const SamplerCreateInfo& inCreateInfo)
+    Common::UniquePtr<Sampler> DX12Device::CreateSampler(const SamplerCreateInfo& inCreateInfo)
     {
         return { new DX12Sampler(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<BindGroupLayout> DX12Device::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo)
+    Common::UniquePtr<BindGroupLayout> DX12Device::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo)
     {
         return { new DX12BindGroupLayout(inCreateInfo) };
     }
 
-    Common::UniqueRef<BindGroup> DX12Device::CreateBindGroup(const BindGroupCreateInfo& inCreateInfo)
+    Common::UniquePtr<BindGroup> DX12Device::CreateBindGroup(const BindGroupCreateInfo& inCreateInfo)
     {
         return { new DX12BindGroup(inCreateInfo) };
     }
 
-    Common::UniqueRef<PipelineLayout> DX12Device::CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo)
+    Common::UniquePtr<PipelineLayout> DX12Device::CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo)
     {
         return { new DX12PipelineLayout(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<ShaderModule> DX12Device::CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo)
+    Common::UniquePtr<ShaderModule> DX12Device::CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo)
     {
         return { new DX12ShaderModule(inCreateInfo) };
     }
 
-    Common::UniqueRef<ComputePipeline> DX12Device::CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo)
+    Common::UniquePtr<ComputePipeline> DX12Device::CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo)
     {
         return { new DX12ComputePipeline(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<RasterPipeline> DX12Device::CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo)
+    Common::UniquePtr<RasterPipeline> DX12Device::CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo)
     {
         return { new DX12RasterPipeline(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<CommandBuffer> DX12Device::CreateCommandBuffer()
+    Common::UniquePtr<CommandBuffer> DX12Device::CreateCommandBuffer()
     {
         return { new DX12CommandBuffer(*this) };
     }
 
-    Common::UniqueRef<Fence> DX12Device::CreateFence(const bool inInitAsSignaled)
+    Common::UniquePtr<Fence> DX12Device::CreateFence(const bool inInitAsSignaled)
     {
         return { new DX12Fence(*this, inInitAsSignaled) };
     }
 
-    Common::UniqueRef<Semaphore> DX12Device::CreateSemaphore()
+    Common::UniquePtr<Semaphore> DX12Device::CreateSemaphore()
     {
         return { new DX12Semaphore(*this) };
     }
@@ -289,22 +283,22 @@ namespace RHI::DirectX12 {
         return nativeDevice.Get();
     }
 
-    Common::UniqueRef<DescriptorAllocation> DX12Device::AllocateRtvDescriptor() const
+    Common::UniquePtr<DescriptorAllocation> DX12Device::AllocateRtvDescriptor() const
     {
         return rtvDescriptorPool->Allocate();
     }
 
-    Common::UniqueRef<DescriptorAllocation> DX12Device::AllocateCbvSrvUavDescriptor() const
+    Common::UniquePtr<DescriptorAllocation> DX12Device::AllocateCbvSrvUavDescriptor() const
     {
         return cbvSrvUavDescriptorPool->Allocate();
     }
 
-    Common::UniqueRef<DescriptorAllocation> DX12Device::AllocateSamplerDescriptor() const
+    Common::UniquePtr<DescriptorAllocation> DX12Device::AllocateSamplerDescriptor() const
     {
         return samplerDescriptorPool->Allocate();
     }
 
-    Common::UniqueRef<DescriptorAllocation> DX12Device::AllocateDsvDescriptor() const
+    Common::UniquePtr<DescriptorAllocation> DX12Device::AllocateDsvDescriptor() const
     {
         return dsvDescriptorPool->Allocate();
     }
@@ -327,7 +321,7 @@ namespace RHI::DirectX12 {
         }
 
         for (auto iter : queueNumMap) {
-            std::vector<Common::UniqueRef<DX12Queue>> tempQueues(iter.second);
+            std::vector<Common::UniquePtr<DX12Queue>> tempQueues(iter.second);
 
             D3D12_COMMAND_QUEUE_DESC queueDesc {};
             queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
@@ -342,11 +336,6 @@ namespace RHI::DirectX12 {
         }
     }
 
-    void DX12Device::CreateNativeCmdAllocator()
-    {
-        nativeDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&nativeCmdAllocator));
-    }
-
     void DX12Device::QueryNativeDescriptorSize()
     {
         nativeRtvDescriptorSize = nativeDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
diff --git a/Engine/Source/RHI-DirectX12/Src/Gpu.cpp b/Engine/Source/RHI-DirectX12/Src/Gpu.cpp
index 9729a1c23..f80bed93b 100644
--- a/Engine/Source/RHI-DirectX12/Src/Gpu.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/Gpu.cpp
@@ -37,8 +37,8 @@ namespace RHI::DirectX12 {
         return nativeAdapter.Get();
     }
 
-    Common::UniqueRef<Device> DX12Gpu::RequestDevice(const DeviceCreateInfo& inCreateInfo)
+    Common::UniquePtr<Device> DX12Gpu::RequestDevice(const DeviceCreateInfo& inCreateInfo)
     {
-        return Common::UniqueRef<Device>(new DX12Device(*this, inCreateInfo));
+        return Common::UniquePtr<Device>(new DX12Device(*this, inCreateInfo));
     }
 }
diff --git a/Engine/Source/RHI-DirectX12/Src/Queue.cpp b/Engine/Source/RHI-DirectX12/Src/Queue.cpp
index 27cf81e2a..ca700b262 100644
--- a/Engine/Source/RHI-DirectX12/Src/Queue.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/Queue.cpp
@@ -24,7 +24,7 @@ namespace RHI::DirectX12 {
             Assert(SUCCEEDED(nativeCmdQueue->Wait(waitSemaphore->GetNative(), 1)));
         }
 
-        std::array<ID3D12CommandList*, 1> cmdListsToExecute = { commandBuffer->GetNative() };
+        std::array<ID3D12CommandList*, 1> cmdListsToExecute = { commandBuffer->GetNativeCmdList() };
         nativeCmdQueue->ExecuteCommandLists(cmdListsToExecute.size(), cmdListsToExecute.data());
 
         for (auto i = 0; i < inSubmitInfo.signalSemaphores.size(); i++) {
diff --git a/Engine/Source/RHI-DirectX12/Src/Texture.cpp b/Engine/Source/RHI-DirectX12/Src/Texture.cpp
index 39d6398d5..0b96994fb 100644
--- a/Engine/Source/RHI-DirectX12/Src/Texture.cpp
+++ b/Engine/Source/RHI-DirectX12/Src/Texture.cpp
@@ -26,9 +26,9 @@ namespace RHI::DirectX12 {
 
     DX12Texture::~DX12Texture() = default;
 
-    Common::UniqueRef<TextureView> DX12Texture::CreateTextureView(const TextureViewCreateInfo& inCreateInfo)
+    Common::UniquePtr<TextureView> DX12Texture::CreateTextureView(const TextureViewCreateInfo& inCreateInfo)
     {
-        return Common::UniqueRef<TextureView>(new DX12TextureView(static_cast<DX12Device&>(device), *this, inCreateInfo));
+        return Common::UniquePtr<TextureView>(new DX12TextureView(static_cast<DX12Device&>(device), *this, inCreateInfo));
     }
 
     ID3D12Resource* DX12Texture::GetNative() const
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Buffer.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Buffer.h
index 379b34c18..58c779d30 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Buffer.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Buffer.h
@@ -16,7 +16,7 @@ namespace RHI::Dummy {
 
         void* Map(MapMode mapMode, size_t offset, size_t length) override;
         void UnMap() override;
-        Common::UniqueRef<BufferView> CreateBufferView(const BufferViewCreateInfo& createInfo) override;
+        Common::UniquePtr<BufferView> CreateBufferView(const BufferViewCreateInfo& createInfo) override;
     private:
         std::vector<uint8_t> dummyData;
     };
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandBuffer.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandBuffer.h
index 2c20be032..3334920b2 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandBuffer.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandBuffer.h
@@ -12,6 +12,6 @@ namespace RHI::Dummy {
         NonCopyable(DummyCommandBuffer)
         DummyCommandBuffer();
 
-        Common::UniqueRef<CommandRecorder> Begin() override;
+        Common::UniquePtr<CommandRecorder> Begin() override;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandRecorder.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandRecorder.h
index 746a04564..b1c983ab4 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandRecorder.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/CommandRecorder.h
@@ -16,9 +16,9 @@ namespace RHI::Dummy {
         ~DummyCommandRecorder() override;
 
         void ResourceBarrier(const Barrier& barrier) override;
-        Common::UniqueRef<CopyPassCommandRecorder> BeginCopyPass() override;
-        Common::UniqueRef<ComputePassCommandRecorder> BeginComputePass() override;
-        Common::UniqueRef<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& beginInfo) override;
+        Common::UniquePtr<CopyPassCommandRecorder> BeginCopyPass() override;
+        Common::UniquePtr<ComputePassCommandRecorder> BeginComputePass() override;
+        Common::UniquePtr<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& beginInfo) override;
         void End() override;
 
     private:
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Device.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Device.h
index 4310cf2f8..993d78d76 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Device.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Device.h
@@ -17,25 +17,25 @@ namespace RHI::Dummy {
         
         size_t GetQueueNum(QueueType type) override;
         Queue* GetQueue(QueueType type, size_t index) override;
-        Common::UniqueRef<Surface> CreateSurface(const RHI::SurfaceCreateInfo &createInfo) override;
-        Common::UniqueRef<SwapChain> CreateSwapChain(const SwapChainCreateInfo& createInfo) override;
-        Common::UniqueRef<Buffer> CreateBuffer(const BufferCreateInfo& createInfo) override;
-        Common::UniqueRef<Texture> CreateTexture(const TextureCreateInfo& createInfo) override;
-        Common::UniqueRef<Sampler> CreateSampler(const SamplerCreateInfo& createInfo) override;
-        Common::UniqueRef<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo) override;
-        Common::UniqueRef<BindGroup> CreateBindGroup(const BindGroupCreateInfo& createInfo) override;
-        Common::UniqueRef<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo) override;
-        Common::UniqueRef<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& createInfo) override;
-        Common::UniqueRef<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& createInfo) override;
-        Common::UniqueRef<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo) override;
-        Common::UniqueRef<CommandBuffer> CreateCommandBuffer() override;
-        Common::UniqueRef<Fence> CreateFence(bool bInitAsSignaled) override;
-        Common::UniqueRef<Semaphore> CreateSemaphore() override;
+        Common::UniquePtr<Surface> CreateSurface(const RHI::SurfaceCreateInfo &createInfo) override;
+        Common::UniquePtr<SwapChain> CreateSwapChain(const SwapChainCreateInfo& createInfo) override;
+        Common::UniquePtr<Buffer> CreateBuffer(const BufferCreateInfo& createInfo) override;
+        Common::UniquePtr<Texture> CreateTexture(const TextureCreateInfo& createInfo) override;
+        Common::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& createInfo) override;
+        Common::UniquePtr<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo) override;
+        Common::UniquePtr<BindGroup> CreateBindGroup(const BindGroupCreateInfo& createInfo) override;
+        Common::UniquePtr<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo) override;
+        Common::UniquePtr<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& createInfo) override;
+        Common::UniquePtr<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& createInfo) override;
+        Common::UniquePtr<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo) override;
+        Common::UniquePtr<CommandBuffer> CreateCommandBuffer() override;
+        Common::UniquePtr<Fence> CreateFence(bool bInitAsSignaled) override;
+        Common::UniquePtr<Semaphore> CreateSemaphore() override;
 
         bool CheckSwapChainFormatSupport(Surface *surface, PixelFormat format) override;
         TextureSubResourceCopyFootprint GetTextureSubResourceCopyFootprint(const Texture& texture, const TextureSubResourceInfo& subResourceInfo) override;
 
     private:
-        Common::UniqueRef<DummyQueue> dummyQueue;
+        Common::UniquePtr<DummyQueue> dummyQueue;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Gpu.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Gpu.h
index 2b8590ac0..932e5de14 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Gpu.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Gpu.h
@@ -13,6 +13,6 @@ namespace RHI::Dummy {
         DummyGpu();
         ~DummyGpu() override;
         GpuProperty GetProperty() override;
-        Common::UniqueRef<Device> RequestDevice(const DeviceCreateInfo& createInfo) override;
+        Common::UniquePtr<Device> RequestDevice(const DeviceCreateInfo& createInfo) override;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Instance.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Instance.h
index 633b26a41..812111a11 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Instance.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Instance.h
@@ -22,6 +22,6 @@ namespace RHI::Dummy {
         void Destroy() override;
 
     private:
-        Common::UniqueRef<DummyGpu> dummyGpu;
+        Common::UniquePtr<DummyGpu> dummyGpu;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/SwapChain.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/SwapChain.h
index 8e33b4e9b..16e8b1795 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/SwapChain.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/SwapChain.h
@@ -24,6 +24,6 @@ namespace RHI::Dummy {
 
     private:
         bool pingPong;
-        std::vector<Common::UniqueRef<DummyTexture>> dummyTextures;
+        std::vector<Common::UniquePtr<DummyTexture>> dummyTextures;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Texture.h b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Texture.h
index a56bc3b67..c395132d7 100644
--- a/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Texture.h
+++ b/Engine/Source/RHI-Dummy/Include/RHI/Dummy/Texture.h
@@ -13,6 +13,6 @@ namespace RHI::Dummy {
         explicit DummyTexture(const TextureCreateInfo& createInfo);
         ~DummyTexture() override;
 
-        Common::UniqueRef<TextureView> CreateTextureView(const TextureViewCreateInfo& createInfo) override;
+        Common::UniquePtr<TextureView> CreateTextureView(const TextureViewCreateInfo& createInfo) override;
     };
 }
diff --git a/Engine/Source/RHI-Dummy/Src/Buffer.cpp b/Engine/Source/RHI-Dummy/Src/Buffer.cpp
index 4b6aac9b7..2530cec0f 100644
--- a/Engine/Source/RHI-Dummy/Src/Buffer.cpp
+++ b/Engine/Source/RHI-Dummy/Src/Buffer.cpp
@@ -23,8 +23,8 @@ namespace RHI::Dummy {
     {
     }
 
-    Common::UniqueRef<BufferView> DummyBuffer::CreateBufferView(const BufferViewCreateInfo& createInfo)
+    Common::UniquePtr<BufferView> DummyBuffer::CreateBufferView(const BufferViewCreateInfo& createInfo)
     {
-        return Common::UniqueRef<BufferView>(new DummyBufferView(createInfo));
+        return Common::UniquePtr<BufferView>(new DummyBufferView(createInfo));
     }
 }
diff --git a/Engine/Source/RHI-Dummy/Src/CommandBuffer.cpp b/Engine/Source/RHI-Dummy/Src/CommandBuffer.cpp
index ef9694601..59e0ce3a8 100644
--- a/Engine/Source/RHI-Dummy/Src/CommandBuffer.cpp
+++ b/Engine/Source/RHI-Dummy/Src/CommandBuffer.cpp
@@ -8,7 +8,7 @@
 namespace RHI::Dummy {
     DummyCommandBuffer::DummyCommandBuffer() = default;
 
-    Common::UniqueRef<CommandRecorder> DummyCommandBuffer::Begin()
+    Common::UniquePtr<CommandRecorder> DummyCommandBuffer::Begin()
     {
         return { new DummyCommandRecorder(*this) };
     }
diff --git a/Engine/Source/RHI-Dummy/Src/CommandRecorder.cpp b/Engine/Source/RHI-Dummy/Src/CommandRecorder.cpp
index d58875a77..f981c7c25 100644
--- a/Engine/Source/RHI-Dummy/Src/CommandRecorder.cpp
+++ b/Engine/Source/RHI-Dummy/Src/CommandRecorder.cpp
@@ -132,19 +132,19 @@ namespace RHI::Dummy {
     {
     }
 
-    Common::UniqueRef<CopyPassCommandRecorder> DummyCommandRecorder::BeginCopyPass()
+    Common::UniquePtr<CopyPassCommandRecorder> DummyCommandRecorder::BeginCopyPass()
     {
-        return Common::UniqueRef<CopyPassCommandRecorder>(new DummyCopyPassCommandRecorder(dummyCommandBuffer));
+        return Common::UniquePtr<CopyPassCommandRecorder>(new DummyCopyPassCommandRecorder(dummyCommandBuffer));
     }
 
-    Common::UniqueRef<ComputePassCommandRecorder> DummyCommandRecorder::BeginComputePass()
+    Common::UniquePtr<ComputePassCommandRecorder> DummyCommandRecorder::BeginComputePass()
     {
-        return Common::UniqueRef<ComputePassCommandRecorder>(new DummyComputePassCommandRecorder(dummyCommandBuffer));
+        return Common::UniquePtr<ComputePassCommandRecorder>(new DummyComputePassCommandRecorder(dummyCommandBuffer));
     }
 
-    Common::UniqueRef<RasterPassCommandRecorder> DummyCommandRecorder::BeginRasterPass(const RasterPassBeginInfo& beginInfo)
+    Common::UniquePtr<RasterPassCommandRecorder> DummyCommandRecorder::BeginRasterPass(const RasterPassBeginInfo& beginInfo)
     {
-        return Common::UniqueRef<RasterPassCommandRecorder>(new DummyRasterPassCommandRecorder(dummyCommandBuffer));
+        return Common::UniquePtr<RasterPassCommandRecorder>(new DummyRasterPassCommandRecorder(dummyCommandBuffer));
     }
 
     void DummyCommandRecorder::End()
diff --git a/Engine/Source/RHI-Dummy/Src/Device.cpp b/Engine/Source/RHI-Dummy/Src/Device.cpp
index 3b75ecadc..6479231e5 100644
--- a/Engine/Source/RHI-Dummy/Src/Device.cpp
+++ b/Engine/Source/RHI-Dummy/Src/Device.cpp
@@ -38,72 +38,72 @@ namespace RHI::Dummy {
         return dummyQueue.Get();
     }
 
-    Common::UniqueRef<Surface> DummyDevice::CreateSurface(const SurfaceCreateInfo& createInfo)
+    Common::UniquePtr<Surface> DummyDevice::CreateSurface(const SurfaceCreateInfo& createInfo)
     {
         return { new DummySurface(createInfo) };
     }
 
-    Common::UniqueRef<SwapChain> DummyDevice::CreateSwapChain(const SwapChainCreateInfo& createInfo)
+    Common::UniquePtr<SwapChain> DummyDevice::CreateSwapChain(const SwapChainCreateInfo& createInfo)
     {
         return { new DummySwapChain(createInfo) };
     }
 
-    Common::UniqueRef<Buffer> DummyDevice::CreateBuffer(const BufferCreateInfo& createInfo)
+    Common::UniquePtr<Buffer> DummyDevice::CreateBuffer(const BufferCreateInfo& createInfo)
     {
         return { new DummyBuffer(createInfo) };
     }
 
-    Common::UniqueRef<Texture> DummyDevice::CreateTexture(const TextureCreateInfo& createInfo)
+    Common::UniquePtr<Texture> DummyDevice::CreateTexture(const TextureCreateInfo& createInfo)
     {
         return { new DummyTexture(createInfo) };
     }
 
-    Common::UniqueRef<Sampler> DummyDevice::CreateSampler(const SamplerCreateInfo& createInfo)
+    Common::UniquePtr<Sampler> DummyDevice::CreateSampler(const SamplerCreateInfo& createInfo)
     {
         return { new DummySampler(createInfo) };
     }
 
-    Common::UniqueRef<BindGroupLayout> DummyDevice::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo)
+    Common::UniquePtr<BindGroupLayout> DummyDevice::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo)
     {
         return { new DummyBindGroupLayout(createInfo) };
     }
 
-    Common::UniqueRef<BindGroup> DummyDevice::CreateBindGroup(const BindGroupCreateInfo& createInfo)
+    Common::UniquePtr<BindGroup> DummyDevice::CreateBindGroup(const BindGroupCreateInfo& createInfo)
     {
         return { new DummyBindGroup(createInfo) };
     }
 
-    Common::UniqueRef<PipelineLayout> DummyDevice::CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo)
+    Common::UniquePtr<PipelineLayout> DummyDevice::CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo)
     {
         return { new DummyPipelineLayout(createInfo) };
     }
 
-    Common::UniqueRef<ShaderModule> DummyDevice::CreateShaderModule(const ShaderModuleCreateInfo& createInfo)
+    Common::UniquePtr<ShaderModule> DummyDevice::CreateShaderModule(const ShaderModuleCreateInfo& createInfo)
     {
         return { new DummyShaderModule(createInfo) };
     }
 
-    Common::UniqueRef<ComputePipeline> DummyDevice::CreateComputePipeline(const ComputePipelineCreateInfo& createInfo)
+    Common::UniquePtr<ComputePipeline> DummyDevice::CreateComputePipeline(const ComputePipelineCreateInfo& createInfo)
     {
         return { new DummyComputePipeline(createInfo) };
     }
 
-    Common::UniqueRef<RasterPipeline> DummyDevice::CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo)
+    Common::UniquePtr<RasterPipeline> DummyDevice::CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo)
     {
         return { new DummyRasterPipeline(createInfo) };
     }
 
-    Common::UniqueRef<CommandBuffer> DummyDevice::CreateCommandBuffer()
+    Common::UniquePtr<CommandBuffer> DummyDevice::CreateCommandBuffer()
     {
         return { new DummyCommandBuffer() };
     }
 
-    Common::UniqueRef<Fence> DummyDevice::CreateFence(const bool bInitAsSignaled)
+    Common::UniquePtr<Fence> DummyDevice::CreateFence(const bool bInitAsSignaled)
     {
         return { new DummyFence(*this, bInitAsSignaled) };
     }
 
-    Common::UniqueRef<Semaphore> DummyDevice::CreateSemaphore()
+    Common::UniquePtr<Semaphore> DummyDevice::CreateSemaphore()
     {
         return { new DummySemaphore(*this) };
     }
diff --git a/Engine/Source/RHI-Dummy/Src/Gpu.cpp b/Engine/Source/RHI-Dummy/Src/Gpu.cpp
index 255e499bf..2d9316678 100644
--- a/Engine/Source/RHI-Dummy/Src/Gpu.cpp
+++ b/Engine/Source/RHI-Dummy/Src/Gpu.cpp
@@ -15,7 +15,7 @@ namespace RHI::Dummy {
         return {};
     }
 
-    Common::UniqueRef<Device> DummyGpu::RequestDevice(const DeviceCreateInfo& createInfo)
+    Common::UniquePtr<Device> DummyGpu::RequestDevice(const DeviceCreateInfo& createInfo)
     {
         return { new DummyDevice(createInfo) };
     }
diff --git a/Engine/Source/RHI-Dummy/Src/Texture.cpp b/Engine/Source/RHI-Dummy/Src/Texture.cpp
index 55977e5ec..9dca25f7e 100644
--- a/Engine/Source/RHI-Dummy/Src/Texture.cpp
+++ b/Engine/Source/RHI-Dummy/Src/Texture.cpp
@@ -13,8 +13,8 @@ namespace RHI::Dummy {
 
     DummyTexture::~DummyTexture() = default;
 
-    Common::UniqueRef<TextureView> DummyTexture::CreateTextureView(const TextureViewCreateInfo& createInfo)
+    Common::UniquePtr<TextureView> DummyTexture::CreateTextureView(const TextureViewCreateInfo& createInfo)
     {
-        return Common::UniqueRef<TextureView>(new DummyTextureView(createInfo));
+        return Common::UniquePtr<TextureView>(new DummyTextureView(createInfo));
     }
 }
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Buffer.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Buffer.h
index 25a683f56..5f7dda84c 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Buffer.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Buffer.h
@@ -21,7 +21,7 @@ namespace RHI::Vulkan {
 
         void* Map(MapMode inMapMode, size_t inOffset, size_t inLength) override;
         void UnMap() override;
-        Common::UniqueRef<BufferView> CreateBufferView(const BufferViewCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BufferView> CreateBufferView(const BufferViewCreateInfo& inCreateInfo) override;
 
         VkBuffer GetNative() const;
         BufferUsageFlags GetUsages() const;
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandBuffer.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandBuffer.h
index bb8f4022e..52141746f 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandBuffer.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandBuffer.h
@@ -19,7 +19,7 @@ namespace RHI::Vulkan {
         VulkanCommandBuffer(VulkanDevice& inDevice, VkCommandPool inNativeCmdPool);
         ~VulkanCommandBuffer() override;
 
-        Common::UniqueRef<CommandRecorder> Begin() override;
+        Common::UniquePtr<CommandRecorder> Begin() override;
 
         VkCommandBuffer GetNative() const;
 
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandRecorder.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandRecorder.h
index 3965710b8..31c5deb51 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandRecorder.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/CommandRecorder.h
@@ -22,9 +22,9 @@ namespace RHI::Vulkan {
         ~VulkanCommandRecorder() override;
 
         void ResourceBarrier(const Barrier& inBarrier) override;
-        Common::UniqueRef<CopyPassCommandRecorder> BeginCopyPass() override;
-        Common::UniqueRef<ComputePassCommandRecorder> BeginComputePass() override;
-        Common::UniqueRef<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& inBeginInfo) override;
+        Common::UniquePtr<CopyPassCommandRecorder> BeginCopyPass() override;
+        Common::UniquePtr<ComputePassCommandRecorder> BeginComputePass() override;
+        Common::UniquePtr<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& inBeginInfo) override;
         void End() override;
 
     private:
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Device.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Device.h
index a29ed5abb..aa7578604 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Device.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Device.h
@@ -25,20 +25,20 @@ namespace RHI::Vulkan {
 
         size_t GetQueueNum(QueueType inType) override;
         Queue* GetQueue(QueueType inType, size_t inIndex) override;
-        Common::UniqueRef<Surface> CreateSurface(const SurfaceCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<SwapChain> CreateSwapChain(const SwapChainCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Buffer> CreateBuffer(const BufferCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Texture> CreateTexture(const TextureCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<Sampler> CreateSampler(const SamplerCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<BindGroup> CreateBindGroup(const BindGroupCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo) override;
-        Common::UniqueRef<CommandBuffer> CreateCommandBuffer() override;
-        Common::UniqueRef<Fence> CreateFence(bool initAsSignaled) override;
-        Common::UniqueRef<Semaphore> CreateSemaphore() override;
+        Common::UniquePtr<Surface> CreateSurface(const SurfaceCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<SwapChain> CreateSwapChain(const SwapChainCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Buffer> CreateBuffer(const BufferCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Texture> CreateTexture(const TextureCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<BindGroup> CreateBindGroup(const BindGroupCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<CommandBuffer> CreateCommandBuffer() override;
+        Common::UniquePtr<Fence> CreateFence(bool initAsSignaled) override;
+        Common::UniquePtr<Semaphore> CreateSemaphore() override;
 
         bool CheckSwapChainFormatSupport(Surface* inSurface, PixelFormat inFormat) override;
         TextureSubResourceCopyFootprint GetTextureSubResourceCopyFootprint(const Texture& texture, const TextureSubResourceInfo& subResourceInfo) override;
@@ -61,7 +61,7 @@ namespace RHI::Vulkan {
         VkDevice nativeDevice;
         VmaAllocator nativeAllocator;
         std::unordered_map<QueueType, std::pair<uint32_t, uint32_t>> queueFamilyMappings;
-        std::unordered_map<QueueType, std::vector<Common::UniqueRef<VulkanQueue>>> queues;
+        std::unordered_map<QueueType, std::vector<Common::UniquePtr<VulkanQueue>>> queues;
         std::unordered_map<QueueType, VkCommandPool> nativeCmdPools;
     };
 }
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Gpu.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Gpu.h
index b0215db51..55ffe1563 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Gpu.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Gpu.h
@@ -18,7 +18,7 @@ namespace RHI::Vulkan {
         ~VulkanGpu() override;
 
         GpuProperty GetProperty() override;
-        Common::UniqueRef<Device> RequestDevice(const DeviceCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<Device> RequestDevice(const DeviceCreateInfo& inCreateInfo) override;
 
         VkPhysicalDevice GetNative() const;
         VulkanInstance& GetInstance() const;
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Instance.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Instance.h
index a7a16121f..3ff02b2b8 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Instance.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Instance.h
@@ -54,7 +54,7 @@ namespace RHI::Vulkan {
 #endif
         VkInstance nativeInstance;
         std::vector<VkPhysicalDevice> nativePhysicalDevices;
-        std::vector<Common::UniqueRef<Gpu>> gpus;
+        std::vector<Common::UniquePtr<Gpu>> gpus;
         std::unordered_map<std::string, PFN_vkVoidFunction> dynamicFuncPointers;
     };
 }
diff --git a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Texture.h b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Texture.h
index ce8269b06..ecadd0bb8 100644
--- a/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Texture.h
+++ b/Engine/Source/RHI-Vulkan/Include/RHI/Vulkan/Texture.h
@@ -23,7 +23,7 @@ namespace RHI::Vulkan {
         VulkanTexture(VulkanDevice& inDevice, const TextureCreateInfo& inCreateInfo);
         ~VulkanTexture() override;
 
-        Common::UniqueRef<TextureView> CreateTextureView(const TextureViewCreateInfo& inCreateInfo) override;
+        Common::UniquePtr<TextureView> CreateTextureView(const TextureViewCreateInfo& inCreateInfo) override;
 
         VkImage GetNative() const;
         VkImageSubresourceRange GetNativeSubResourceFullRange() const;
diff --git a/Engine/Source/RHI-Vulkan/Src/Buffer.cpp b/Engine/Source/RHI-Vulkan/Src/Buffer.cpp
index cf76de313..ffd8456b7 100644
--- a/Engine/Source/RHI-Vulkan/Src/Buffer.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/Buffer.cpp
@@ -40,9 +40,9 @@ namespace RHI::Vulkan {
         vmaUnmapMemory(device.GetNativeAllocator(), nativeAllocation);
     }
 
-    Common::UniqueRef<BufferView> VulkanBuffer::CreateBufferView(const BufferViewCreateInfo& inCreateInfo)
+    Common::UniquePtr<BufferView> VulkanBuffer::CreateBufferView(const BufferViewCreateInfo& inCreateInfo)
     {
-        return Common::UniqueRef<BufferView>(new VulkanBufferView(*this, inCreateInfo));
+        return Common::UniquePtr<BufferView>(new VulkanBufferView(*this, inCreateInfo));
     }
 
     void VulkanBuffer::CreateNativeBuffer(const BufferCreateInfo& inCreateInfo)
diff --git a/Engine/Source/RHI-Vulkan/Src/CommandBuffer.cpp b/Engine/Source/RHI-Vulkan/Src/CommandBuffer.cpp
index a55668d38..ee858efe7 100644
--- a/Engine/Source/RHI-Vulkan/Src/CommandBuffer.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/CommandBuffer.cpp
@@ -23,7 +23,7 @@ namespace RHI::Vulkan {
         }
     }
 
-    Common::UniqueRef<CommandRecorder> VulkanCommandBuffer::Begin()
+    Common::UniquePtr<CommandRecorder> VulkanCommandBuffer::Begin()
     {
         VkCommandBufferBeginInfo beginInfo = {};
         beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
diff --git a/Engine/Source/RHI-Vulkan/Src/CommandRecorder.cpp b/Engine/Source/RHI-Vulkan/Src/CommandRecorder.cpp
index 2e690d908..92ef7f8d8 100644
--- a/Engine/Source/RHI-Vulkan/Src/CommandRecorder.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/CommandRecorder.cpp
@@ -209,19 +209,19 @@ namespace RHI::Vulkan {
         }
     }
 
-    Common::UniqueRef<CopyPassCommandRecorder> VulkanCommandRecorder::BeginCopyPass()
+    Common::UniquePtr<CopyPassCommandRecorder> VulkanCommandRecorder::BeginCopyPass()
     {
-        return Common::UniqueRef<CopyPassCommandRecorder>(new VulkanCopyPassCommandRecorder(device, *this, commandBuffer));
+        return Common::UniquePtr<CopyPassCommandRecorder>(new VulkanCopyPassCommandRecorder(device, *this, commandBuffer));
     }
 
-    Common::UniqueRef<ComputePassCommandRecorder> VulkanCommandRecorder::BeginComputePass()
+    Common::UniquePtr<ComputePassCommandRecorder> VulkanCommandRecorder::BeginComputePass()
     {
-        return Common::UniqueRef<ComputePassCommandRecorder>(new VulkanComputePassCommandRecorder(device, *this, commandBuffer));
+        return Common::UniquePtr<ComputePassCommandRecorder>(new VulkanComputePassCommandRecorder(device, *this, commandBuffer));
     }
 
-    Common::UniqueRef<RasterPassCommandRecorder> VulkanCommandRecorder::BeginRasterPass(const RasterPassBeginInfo& inBeginInfo)
+    Common::UniquePtr<RasterPassCommandRecorder> VulkanCommandRecorder::BeginRasterPass(const RasterPassBeginInfo& inBeginInfo)
     {
-        return Common::UniqueRef<RasterPassCommandRecorder>(new VulkanRasterPassCommandRecorder(device, *this, commandBuffer, inBeginInfo));
+        return Common::UniquePtr<RasterPassCommandRecorder>(new VulkanRasterPassCommandRecorder(device, *this, commandBuffer, inBeginInfo));
     }
 
     void VulkanCommandRecorder::End()
diff --git a/Engine/Source/RHI-Vulkan/Src/Device.cpp b/Engine/Source/RHI-Vulkan/Src/Device.cpp
index 1814a48ad..d98ee1177 100644
--- a/Engine/Source/RHI-Vulkan/Src/Device.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/Device.cpp
@@ -72,72 +72,72 @@ namespace RHI::Vulkan {
         return queueArray[inIndex].Get();
     }
 
-    Common::UniqueRef<Surface> VulkanDevice::CreateSurface(const SurfaceCreateInfo& inCreateInfo)
+    Common::UniquePtr<Surface> VulkanDevice::CreateSurface(const SurfaceCreateInfo& inCreateInfo)
     {
         return { new VulkanSurface(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<SwapChain> VulkanDevice::CreateSwapChain(const SwapChainCreateInfo& inCreateInfo)
+    Common::UniquePtr<SwapChain> VulkanDevice::CreateSwapChain(const SwapChainCreateInfo& inCreateInfo)
     {
         return { new VulkanSwapChain(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<Buffer> VulkanDevice::CreateBuffer(const BufferCreateInfo& inCreateInfo)
+    Common::UniquePtr<Buffer> VulkanDevice::CreateBuffer(const BufferCreateInfo& inCreateInfo)
     {
         return { new VulkanBuffer(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<Texture> VulkanDevice::CreateTexture(const TextureCreateInfo& inCreateInfo)
+    Common::UniquePtr<Texture> VulkanDevice::CreateTexture(const TextureCreateInfo& inCreateInfo)
     {
         return { new VulkanTexture(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<Sampler> VulkanDevice::CreateSampler(const SamplerCreateInfo& inCreateInfo)
+    Common::UniquePtr<Sampler> VulkanDevice::CreateSampler(const SamplerCreateInfo& inCreateInfo)
     {
         return { new VulkanSampler(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<BindGroupLayout> VulkanDevice::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo)
+    Common::UniquePtr<BindGroupLayout> VulkanDevice::CreateBindGroupLayout(const BindGroupLayoutCreateInfo& inCreateInfo)
     {
         return { new VulkanBindGroupLayout(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<BindGroup> VulkanDevice::CreateBindGroup(const BindGroupCreateInfo& inCreateInfo)
+    Common::UniquePtr<BindGroup> VulkanDevice::CreateBindGroup(const BindGroupCreateInfo& inCreateInfo)
     {
         return { new VulkanBindGroup(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<PipelineLayout> VulkanDevice::CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo)
+    Common::UniquePtr<PipelineLayout> VulkanDevice::CreatePipelineLayout(const PipelineLayoutCreateInfo& inCreateInfo)
     {
         return { new VulkanPipelineLayout(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<ShaderModule> VulkanDevice::CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo)
+    Common::UniquePtr<ShaderModule> VulkanDevice::CreateShaderModule(const ShaderModuleCreateInfo& inCreateInfo)
     {
         return { new VulkanShaderModule(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<ComputePipeline> VulkanDevice::CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo)
+    Common::UniquePtr<ComputePipeline> VulkanDevice::CreateComputePipeline(const ComputePipelineCreateInfo& inCreateInfo)
     {
         return { new VulkanComputePipeline(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<RasterPipeline> VulkanDevice::CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo)
+    Common::UniquePtr<RasterPipeline> VulkanDevice::CreateRasterPipeline(const RasterPipelineCreateInfo& inCreateInfo)
     {
         return { new VulkanRasterPipeline(*this, inCreateInfo) };
     }
 
-    Common::UniqueRef<CommandBuffer> VulkanDevice::CreateCommandBuffer()
+    Common::UniquePtr<CommandBuffer> VulkanDevice::CreateCommandBuffer()
     {
         return { new VulkanCommandBuffer(*this, nativeCmdPools[QueueType::graphics]) };
     }
 
-    Common::UniqueRef<Fence> VulkanDevice::CreateFence(const bool initAsSignaled)
+    Common::UniquePtr<Fence> VulkanDevice::CreateFence(const bool initAsSignaled)
     {
         return { new VulkanFence(*this, initAsSignaled) };
     }
 
-    Common::UniqueRef<Semaphore> VulkanDevice::CreateSemaphore()
+    Common::UniquePtr<Semaphore> VulkanDevice::CreateSemaphore()
     {
         return { new VulkanSemaphore(*this) };
     }
@@ -260,9 +260,6 @@ namespace RHI::Vulkan {
         dynamicRenderingFeatures.dynamicRendering = VK_TRUE;
         deviceCreateInfo.pNext = &dynamicRenderingFeatures;
 
-        deviceCreateInfo.ppEnabledExtensionNames = requiredExtensions.data();
-        deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(requiredExtensions.size());
-
 #if PLATFORM_MACOS
         // MoltenVK not support use vkCmdSetPrimitiveTopology() directly current
         VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extendedDynamicStateFeatures = {};
@@ -271,6 +268,9 @@ namespace RHI::Vulkan {
         dynamicRenderingFeatures.pNext = &extendedDynamicStateFeatures;
 #endif
 
+        deviceCreateInfo.ppEnabledExtensionNames = requiredExtensions.data();
+        deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(requiredExtensions.size());
+
 #if BUILD_CONFIG_DEBUG
         deviceCreateInfo.enabledLayerCount = static_cast<uint32_t>(requiredValidationLayers.size());
         deviceCreateInfo.ppEnabledLayerNames = requiredValidationLayers.data();
@@ -288,7 +288,7 @@ namespace RHI::Vulkan {
         for (auto [queueType, queueFamilyInfo] : queueFamilyMappings) {
             auto [queueFamilyIndex, queueNum] = queueFamilyInfo;
 
-            std::vector<Common::UniqueRef<VulkanQueue>> tempQueues(queueNum);
+            std::vector<Common::UniquePtr<VulkanQueue>> tempQueues(queueNum);
             for (auto i = 0; i < tempQueues.size(); i++) {
                 VkQueue queue;
                 vkGetDeviceQueue(nativeDevice, queueFamilyIndex, i, &queue);
diff --git a/Engine/Source/RHI-Vulkan/Src/Gpu.cpp b/Engine/Source/RHI-Vulkan/Src/Gpu.cpp
index cda43d49d..f5647bd82 100644
--- a/Engine/Source/RHI-Vulkan/Src/Gpu.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/Gpu.cpp
@@ -27,7 +27,7 @@ namespace RHI::Vulkan {
         return property;
     }
 
-    Common::UniqueRef<Device> VulkanGpu::RequestDevice(const DeviceCreateInfo& inCreateInfo)
+    Common::UniquePtr<Device> VulkanGpu::RequestDevice(const DeviceCreateInfo& inCreateInfo)
     {
         return { new VulkanDevice(*this, inCreateInfo) };
     }
diff --git a/Engine/Source/RHI-Vulkan/Src/Texture.cpp b/Engine/Source/RHI-Vulkan/Src/Texture.cpp
index f44c2a527..61f6163a8 100644
--- a/Engine/Source/RHI-Vulkan/Src/Texture.cpp
+++ b/Engine/Source/RHI-Vulkan/Src/Texture.cpp
@@ -40,9 +40,9 @@ namespace RHI::Vulkan {
         }
     }
 
-    Common::UniqueRef<TextureView> VulkanTexture::CreateTextureView(const TextureViewCreateInfo& inCreateInfo)
+    Common::UniquePtr<TextureView> VulkanTexture::CreateTextureView(const TextureViewCreateInfo& inCreateInfo)
     {
-        return Common::UniqueRef<TextureView>(new VulkanTextureView(*this, device, inCreateInfo));
+        return Common::UniquePtr<TextureView>(new VulkanTextureView(*this, device, inCreateInfo));
     }
 
     VkImage VulkanTexture::GetNative() const
diff --git a/Engine/Source/RHI/Include/RHI/Buffer.h b/Engine/Source/RHI/Include/RHI/Buffer.h
index de6e98423..80ceec45c 100644
--- a/Engine/Source/RHI/Include/RHI/Buffer.h
+++ b/Engine/Source/RHI/Include/RHI/Buffer.h
@@ -37,7 +37,7 @@ namespace RHI {
         const BufferCreateInfo& GetCreateInfo() const;
         virtual void* Map(MapMode mapMode, size_t offset, size_t length) = 0;
         virtual void UnMap() = 0;
-        virtual Common::UniqueRef<BufferView> CreateBufferView(const BufferViewCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<BufferView> CreateBufferView(const BufferViewCreateInfo& createInfo) = 0;
 
     protected:
         explicit Buffer(const BufferCreateInfo& inCreateInfo);
diff --git a/Engine/Source/RHI/Include/RHI/CommandBuffer.h b/Engine/Source/RHI/Include/RHI/CommandBuffer.h
index 22104403e..9209e6e58 100644
--- a/Engine/Source/RHI/Include/RHI/CommandBuffer.h
+++ b/Engine/Source/RHI/Include/RHI/CommandBuffer.h
@@ -15,7 +15,7 @@ namespace RHI {
         NonCopyable(CommandBuffer)
         virtual ~CommandBuffer();
 
-        virtual Common::UniqueRef<CommandRecorder> Begin() = 0;
+        virtual Common::UniquePtr<CommandRecorder> Begin() = 0;
 
     protected:
         CommandBuffer();
diff --git a/Engine/Source/RHI/Include/RHI/CommandRecorder.h b/Engine/Source/RHI/Include/RHI/CommandRecorder.h
index 9c44d6b84..fcd40695d 100644
--- a/Engine/Source/RHI/Include/RHI/CommandRecorder.h
+++ b/Engine/Source/RHI/Include/RHI/CommandRecorder.h
@@ -246,9 +246,9 @@ namespace RHI {
         NonCopyable(CommandRecorder)
         ~CommandRecorder() override;
 
-        virtual Common::UniqueRef<CopyPassCommandRecorder> BeginCopyPass() = 0;
-        virtual Common::UniqueRef<ComputePassCommandRecorder> BeginComputePass() = 0;
-        virtual Common::UniqueRef<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& beginInfo) = 0;
+        virtual Common::UniquePtr<CopyPassCommandRecorder> BeginCopyPass() = 0;
+        virtual Common::UniquePtr<ComputePassCommandRecorder> BeginComputePass() = 0;
+        virtual Common::UniquePtr<RasterPassCommandRecorder> BeginRasterPass(const RasterPassBeginInfo& beginInfo) = 0;
         virtual void End() = 0;
 
     protected:
diff --git a/Engine/Source/RHI/Include/RHI/Device.h b/Engine/Source/RHI/Include/RHI/Device.h
index f7b564900..f1ecce2d9 100644
--- a/Engine/Source/RHI/Include/RHI/Device.h
+++ b/Engine/Source/RHI/Include/RHI/Device.h
@@ -64,20 +64,20 @@ namespace RHI {
 
         virtual size_t GetQueueNum(QueueType type) = 0;
         virtual Queue* GetQueue(QueueType type, size_t index) = 0;
-        virtual Common::UniqueRef<Surface> CreateSurface(const SurfaceCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<SwapChain> CreateSwapChain(const SwapChainCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<Buffer> CreateBuffer(const BufferCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<Texture> CreateTexture(const TextureCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<Sampler> CreateSampler(const SamplerCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<BindGroup> CreateBindGroup(const BindGroupCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo) = 0;
-        virtual Common::UniqueRef<CommandBuffer> CreateCommandBuffer() = 0;
-        virtual Common::UniqueRef<Fence> CreateFence(bool bInitAsSignaled) = 0;
-        virtual Common::UniqueRef<Semaphore> CreateSemaphore() = 0;
+        virtual Common::UniquePtr<Surface> CreateSurface(const SurfaceCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<SwapChain> CreateSwapChain(const SwapChainCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<Buffer> CreateBuffer(const BufferCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<Texture> CreateTexture(const TextureCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<Sampler> CreateSampler(const SamplerCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<BindGroupLayout> CreateBindGroupLayout(const BindGroupLayoutCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<BindGroup> CreateBindGroup(const BindGroupCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<PipelineLayout> CreatePipelineLayout(const PipelineLayoutCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<ShaderModule> CreateShaderModule(const ShaderModuleCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<ComputePipeline> CreateComputePipeline(const ComputePipelineCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<RasterPipeline> CreateRasterPipeline(const RasterPipelineCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<CommandBuffer> CreateCommandBuffer() = 0;
+        virtual Common::UniquePtr<Fence> CreateFence(bool bInitAsSignaled) = 0;
+        virtual Common::UniquePtr<Semaphore> CreateSemaphore() = 0;
 
         virtual bool CheckSwapChainFormatSupport(Surface* surface, PixelFormat format) = 0;
         virtual TextureSubResourceCopyFootprint GetTextureSubResourceCopyFootprint(const Texture& texture, const TextureSubResourceInfo& subResourceInfo) = 0;
diff --git a/Engine/Source/RHI/Include/RHI/Gpu.h b/Engine/Source/RHI/Include/RHI/Gpu.h
index 8a298ee19..91d64ac50 100644
--- a/Engine/Source/RHI/Include/RHI/Gpu.h
+++ b/Engine/Source/RHI/Include/RHI/Gpu.h
@@ -24,7 +24,7 @@ namespace RHI {
         NonCopyable(Gpu)
         virtual ~Gpu();
         virtual GpuProperty GetProperty() = 0;
-        virtual Common::UniqueRef<Device> RequestDevice(const DeviceCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<Device> RequestDevice(const DeviceCreateInfo& createInfo) = 0;
 
     protected:
         Gpu();
diff --git a/Engine/Source/RHI/Include/RHI/Texture.h b/Engine/Source/RHI/Include/RHI/Texture.h
index 9d73c0a67..132a40623 100644
--- a/Engine/Source/RHI/Include/RHI/Texture.h
+++ b/Engine/Source/RHI/Include/RHI/Texture.h
@@ -46,7 +46,7 @@ namespace RHI {
         virtual ~Texture();
 
         const TextureCreateInfo& GetCreateInfo() const;
-        virtual Common::UniqueRef<TextureView> CreateTextureView(const TextureViewCreateInfo& createInfo) = 0;
+        virtual Common::UniquePtr<TextureView> CreateTextureView(const TextureViewCreateInfo& createInfo) = 0;
 
     protected:
         explicit Texture(const TextureCreateInfo& inCreateInfo);
diff --git a/Engine/Source/Render/Include/Render/RenderCache.h b/Engine/Source/Render/Include/Render/RenderCache.h
index ffdb9873e..2bbb1430e 100644
--- a/Engine/Source/Render/Include/Render/RenderCache.h
+++ b/Engine/Source/Render/Include/Render/RenderCache.h
@@ -142,7 +142,7 @@ namespace Render {
 
         Sampler(RHI::Device& inDevice, const RSamplerDesc& inDesc);
 
-        Common::UniqueRef<RHI::Sampler> rhiHandle;
+        Common::UniquePtr<RHI::Sampler> rhiHandle;
     };
 
     class BindGroupLayout {
@@ -159,7 +159,7 @@ namespace Render {
         BindGroupLayout(RHI::Device& inDevice, const BindGroupLayoutDesc& inDesc);
 
         RBindingMap bindings;
-        Common::UniqueRef<RHI::BindGroupLayout> rhiHandle;
+        Common::UniquePtr<RHI::BindGroupLayout> rhiHandle;
     };
 
     class PipelineLayout {
@@ -184,8 +184,8 @@ namespace Render {
         void CreateRHIPipelineLayout(RHI::Device& device);
 
         size_t hash;
-        std::unordered_map<uint32_t, Common::UniqueRef<BindGroupLayout>> bindGroupLayouts;
-        Common::UniqueRef<RHI::PipelineLayout> rhiHandle;
+        std::unordered_map<uint32_t, Common::UniquePtr<BindGroupLayout>> bindGroupLayouts;
+        Common::UniquePtr<RHI::PipelineLayout> rhiHandle;
     };
 
     class ComputePipelineState {
@@ -204,7 +204,7 @@ namespace Render {
 
         size_t hash;
         PipelineLayout* pipelineLayout;
-        Common::UniqueRef<RHI::ComputePipeline> rhiHandle;
+        Common::UniquePtr<RHI::ComputePipeline> rhiHandle;
     };
 
     class RasterPipelineState {
@@ -222,7 +222,7 @@ namespace Render {
 
         size_t hash;
         PipelineLayout* pipelineLayout;
-        Common::UniqueRef<RHI::RasterPipeline> rhiHandle;
+        Common::UniquePtr<RHI::RasterPipeline> rhiHandle;
     };
 
     class SamplerCache {
@@ -236,7 +236,7 @@ namespace Render {
         explicit SamplerCache(RHI::Device& inDevice);
 
         RHI::Device& device;
-        std::unordered_map<size_t, Common::UniqueRef<Sampler>> samplers;
+        std::unordered_map<size_t, Common::UniquePtr<Sampler>> samplers;
     };
 
     class PipelineCache {
@@ -253,8 +253,8 @@ namespace Render {
         explicit PipelineCache(RHI::Device& inDevice);
 
         RHI::Device& device;
-        std::unordered_map<size_t, Common::UniqueRef<ComputePipelineState>> computePipelines;
-        std::unordered_map<size_t, Common::UniqueRef<RasterPipelineState>> rasterPipelines;
+        std::unordered_map<size_t, Common::UniquePtr<ComputePipelineState>> computePipelines;
+        std::unordered_map<size_t, Common::UniquePtr<RasterPipelineState>> rasterPipelines;
     };
 
     class ResourceViewCache {
@@ -272,7 +272,7 @@ namespace Render {
         explicit ResourceViewCache(RHI::Device& inDevice);
 
         RHI::Device& device;
-        std::unordered_map<RHI::Buffer*, std::unordered_map<size_t, Common::UniqueRef<RHI::BufferView>>> bufferViews;
-        std::unordered_map<RHI::Texture*, std::unordered_map<size_t, Common::UniqueRef<RHI::TextureView>>> textureViews;
+        std::unordered_map<RHI::Buffer*, std::unordered_map<size_t, Common::UniquePtr<RHI::BufferView>>> bufferViews;
+        std::unordered_map<RHI::Texture*, std::unordered_map<size_t, Common::UniquePtr<RHI::TextureView>>> textureViews;
     };
 }
diff --git a/Engine/Source/Render/Include/Render/RenderGraph.h b/Engine/Source/Render/Include/Render/RenderGraph.h
index 3bc1bc093..412b2c674 100644
--- a/Engine/Source/Render/Include/Render/RenderGraph.h
+++ b/Engine/Source/Render/Include/Render/RenderGraph.h
@@ -6,6 +6,7 @@
 
 #include <unordered_map>
 #include <functional>
+#include <future>
 #include <optional>
 
 #include <Common/Memory.h>
@@ -213,6 +214,7 @@ namespace Render {
         RGBindGroupDesc& Sampler(std::string inName, RHI::Sampler* inSampler);
         RGBindGroupDesc& UniformBuffer(std::string inName, RGBufferViewRef bufferView);
         RGBindGroupDesc& StorageBuffer(std::string inName, RGBufferViewRef bufferView);
+        RGBindGroupDesc& RwStorageBuffer(std::string inName, RGBufferViewRef bufferView);
         RGBindGroupDesc& Texture(std::string inName, RGTextureViewRef textureView);
         RGBindGroupDesc& StorageTexture(std::string inName, RGTextureViewRef textureView);
     };
@@ -233,6 +235,16 @@ namespace Render {
 
     using RGBindGroupRef = RGBindGroup*;
 
+    struct RGBufferUploadInfo {
+        void* data;
+        size_t size;
+        size_t srcOffset;
+        size_t dstOffset;
+
+        RGBufferUploadInfo();
+        RGBufferUploadInfo(void* inData, size_t inSize, size_t inSrcOffset = 0, size_t inDstOffset = 0);
+    };
+
     class RGPass {
     public:
         virtual ~RGPass();
@@ -251,6 +263,7 @@ namespace Render {
     using RGCopyPassExecuteFunc = std::function<void(const RGBuilder&, RHI::CopyPassCommandRecorder&)>;
     using RGComputePassExecuteFunc = std::function<void(const RGBuilder&, RHI::ComputePassCommandRecorder&)>;
     using RGRasterPassExecuteFunc = std::function<void(const RGBuilder&, RHI::RasterPassCommandRecorder&)>;
+    using RGCommonPassExecuteFunc = std::function<void(const RGBuilder&, RHI::CommandRecorder&)>;
 
     class RGCopyPass final : public RGPass {
     public:
@@ -259,11 +272,17 @@ namespace Render {
     private:
         friend class RGBuilder;
 
-        // TODO pre/post execute func
-        RGCopyPass(std::string inName, RGCopyPassDesc inPassDesc, RGCopyPassExecuteFunc inFunc);
+        RGCopyPass(
+            std::string inName,
+            RGCopyPassDesc inPassDesc,
+            RGCopyPassExecuteFunc inFunc,
+            RGCommonPassExecuteFunc inPreExecuteFunc = {},
+            RGCommonPassExecuteFunc inPostExecuteFunc = {});
 
         RGCopyPassDesc passDesc;
-        RGCopyPassExecuteFunc func;
+        RGCopyPassExecuteFunc passFunc;
+        RGCommonPassExecuteFunc prePassFunc;
+        RGCommonPassExecuteFunc postPassFunc;
     };
 
     class RGComputePass final : public RGPass {
@@ -273,10 +292,16 @@ namespace Render {
     private:
         friend class RGBuilder;
 
-        // TODO pre/post execute func
-        RGComputePass(std::string inName, std::vector<RGBindGroupRef> inBindGroups, RGComputePassExecuteFunc inFunc);
+        RGComputePass(
+            std::string inName,
+            std::vector<RGBindGroupRef> inBindGroups,
+            RGComputePassExecuteFunc inFunc,
+            RGCommonPassExecuteFunc inPreExecuteFunc = {},
+            RGCommonPassExecuteFunc inPostExecuteFunc = {});
 
-        RGComputePassExecuteFunc func;
+        RGComputePassExecuteFunc passFunc;
+        RGCommonPassExecuteFunc prePassFunc;
+        RGCommonPassExecuteFunc postPassFunc;
         std::vector<RGBindGroupRef> bindGroups;
     };
 
@@ -287,11 +312,17 @@ namespace Render {
     private:
         friend class RGBuilder;
 
-        // TODO pre/post execute func
-        RGRasterPass(std::string inName, RGRasterPassDesc inPassDesc, std::vector<RGBindGroupRef> inBindGroupds, RGRasterPassExecuteFunc inFunc);
+        RGRasterPass(
+            std::string inName, RGRasterPassDesc inPassDesc,
+            std::vector<RGBindGroupRef> inBindGroups,
+            RGRasterPassExecuteFunc inFunc,
+            RGCommonPassExecuteFunc inPreExecuteFunc = {},
+            RGCommonPassExecuteFunc inPostExecuteFunc = {});
 
         RGRasterPassDesc passDesc;
-        RGRasterPassExecuteFunc func;
+        RGRasterPassExecuteFunc passFunc;
+        RGCommonPassExecuteFunc prePassFunc;
+        RGCommonPassExecuteFunc postPassFunc;
         std::vector<RGBindGroupRef> bindGroups;
     };
 
@@ -316,16 +347,14 @@ namespace Render {
         RGBufferRef ImportBuffer(RHI::Buffer* inBuffer, RHI::BufferState inInitialState);
         RGTextureRef ImportTexture(RHI::Texture* inTexture, RHI::TextureState inInitialState);
         RGBindGroupRef AllocateBindGroup(const RGBindGroupDesc& inDesc);
-        void AddCopyPass(const std::string& inName, const RGCopyPassDesc& inPassDesc, const RGCopyPassExecuteFunc& inFunc, bool inAsyncCopy = false);
-        void AddComputePass(const std::string& inName, const std::vector<RGBindGroupRef>& inBindGroups, const RGComputePassExecuteFunc& inFunc, bool inAsyncCompute = false);
-        void AddRasterPass(const std::string& inName, const RGRasterPassDesc& inPassDesc, const std::vector<RGBindGroupRef>& inBindGroupds, const RGRasterPassExecuteFunc& inFunc);
+        void QueueBufferUpload(RGBufferRef inBuffer, const RGBufferUploadInfo& inUploadInfo);
+        void AddCopyPass(const std::string& inName, const RGCopyPassDesc& inPassDesc, const RGCopyPassExecuteFunc& inFunc, bool inAsyncCopy = false, const RGCommonPassExecuteFunc& inPreExecuteFunc = {}, const RGCommonPassExecuteFunc& inPostExecuteFunc = {});
+        void AddComputePass(const std::string& inName, const std::vector<RGBindGroupRef>& inBindGroups, const RGComputePassExecuteFunc& inFunc, bool inAsyncCompute = false, const RGCommonPassExecuteFunc& inPreExecuteFunc = {}, const RGCommonPassExecuteFunc& inPostExecuteFunc = {});
+        void AddRasterPass(const std::string& inName, const RGRasterPassDesc& inPassDesc, const std::vector<RGBindGroupRef>& inBindGroups, const RGRasterPassExecuteFunc& inFunc, const RGCommonPassExecuteFunc& inPreExecuteFunc = {}, const RGCommonPassExecuteFunc& inPostExecuteFunc = {});
         void AddSyncPoint();
-        void Execute(const RGExecuteInfo& inExecuteInfo);
-
-        // TODO upload interface
 
-        // TODO make private
         // execute
+        void Execute(const RGExecuteInfo& inExecuteInfo);
         RHI::Buffer* GetRHI(RGBufferRef inBuffer) const;
         RHI::Texture* GetRHI(RGTextureRef inTexture) const;
         RHI::BufferView* GetRHI(RGBufferViewRef inBufferView) const;
@@ -334,8 +363,8 @@ namespace Render {
 
     private:
         struct AsyncTimelineExecuteContext {
-            std::unordered_map<RGQueueType, Common::UniqueRef<RHI::CommandBuffer>> queueCmdBufferMap;
-            std::unordered_map<RGQueueType, Common::UniqueRef<RHI::Semaphore>> queueSemaphoreToSignalMap;
+            std::unordered_map<RGQueueType, Common::UniquePtr<RHI::CommandBuffer>> queueCmdBufferMap;
+            std::unordered_map<RGQueueType, Common::UniquePtr<RHI::Semaphore>> queueSemaphoreToSignalMap;
 
             AsyncTimelineExecuteContext();
             AsyncTimelineExecuteContext(AsyncTimelineExecuteContext&& inOther) noexcept;
@@ -352,7 +381,10 @@ namespace Render {
         void ExecuteCopyPass(RHI::CommandRecorder& inRecoder, RGCopyPass* inCopyPass);
         void ExecuteComputePass(RHI::CommandRecorder& inRecoder, RGComputePass* inComputePass);
         void ExecuteRasterPass(RHI::CommandRecorder& inRecoder, RGRasterPass* inRasterPass);
+        void PerformBufferUploads();
+        void WaitBufferUploadsFinish() const;
         void DevirtualizeViewsCreatedOnImportedResources();
+        void DevirtualizeResource(RGResourceRef inResource);
         void DevirtualizeResources(const std::unordered_set<RGResourceRef>& inResources);
         void DevirtualizeBindGroupsAndViews(const std::vector<RGBindGroupRef>& inBindGroups);
         void DevirtualizeAttachmentViews(const RGRasterPassDesc& inDesc);
@@ -366,12 +398,13 @@ namespace Render {
 
         bool executed;
         RHI::Device& device;
-        std::vector<Common::UniqueRef<RGResource>> resources;
-        std::vector<Common::UniqueRef<RGResourceView>> views;
-        std::vector<Common::UniqueRef<RGBindGroup>> bindGroups;
-        std::vector<Common::UniqueRef<RGPass>> passes;
+        std::vector<Common::UniquePtr<RGResource>> resources;
+        std::vector<Common::UniquePtr<RGResourceView>> views;
+        std::vector<Common::UniquePtr<RGBindGroup>> bindGroups;
+        std::vector<Common::UniquePtr<RGPass>> passes;
         std::unordered_map<RGQueueType, std::vector<RGPassRef>> recordingAsyncTimeline;
         std::vector<std::unordered_map<RGQueueType, std::vector<RGPassRef>>> asyncTimelines;
+        std::unordered_map<RGBufferRef, RGBufferUploadInfo> bufferUploads;
 
         // execute context
         std::unordered_map<RGResourceRef, uint32_t> resourceReadCounts;
@@ -383,6 +416,7 @@ namespace Render {
         std::vector<AsyncTimelineExecuteContext> asyncTimelineExecuteContexts;
         std::unordered_map<RGResourceRef, std::variant<PooledBufferRef, PooledTextureRef>> devirtualizedResources;
         std::unordered_map<RGResourceViewRef, std::variant<RHI::BufferView*, RHI::TextureView*>> devirtualizedResourceViews;
-        std::unordered_map<RGBindGroupRef, Common::UniqueRef<RHI::BindGroup>> devirtualizedBindGroups;
+        std::unordered_map<RGBindGroupRef, Common::UniquePtr<RHI::BindGroup>> devirtualizedBindGroups;
+        std::vector<std::future<void>> bufferUploadTasks;
     };
 }
diff --git a/Engine/Source/Render/Include/Render/RenderModule.h b/Engine/Source/Render/Include/Render/RenderModule.h
index 4c85772bf..83a78f1e3 100644
--- a/Engine/Source/Render/Include/Render/RenderModule.h
+++ b/Engine/Source/Render/Include/Render/RenderModule.h
@@ -4,14 +4,13 @@
 
 #pragma once
 
-#include <Common/Memory.h>
-#include <Common/Concurrent.h>
 #include <Common/Debug.h>
 #include <Core/Module.h>
+#include <RHI/RHI.h>
 #include <Render/Scene.h>
 #include <Render/View.h>
+#include <Render/RenderThread.h>
 #include <Render/Api.h>
-#include <RHI/RHI.h>
 
 namespace Render {
     struct RenderModuleInitParams {
@@ -30,25 +29,13 @@ namespace Render {
         void Initialize(const RenderModuleInitParams& inParams);
         void DeInitialize();
         RHI::Device* GetDevice() const;
-        Common::UniqueRef<Scene> NewScene();
-        Common::UniqueRef<View> NewView();
-        void ShutdownRenderingThread();
-        void FlushAllRenderingCommands() const;
-        template <typename F, typename... Args> auto EnqueueRenderingCommand(F&& command, Args&&... args);
+        Render::RenderThread& GetRenderThread() const;
+        Common::UniquePtr<Scene> NewScene();
+        Common::UniquePtr<View> NewView();
 
     private:
         bool initialized;
-        Common::UniqueRef<Common::WorkerThread> renderingThread;
         RHI::Instance* rhiInstance;
-        Common::UniqueRef<RHI::Device> rhiDevice;
+        Common::UniquePtr<RHI::Device> rhiDevice;
     };
 }
-
-namespace Render {
-    template <typename F, typename ... Args>
-    auto RenderModule::EnqueueRenderingCommand(F&& command, Args&&... args)
-    {
-        Assert(renderingThread != nullptr);
-        return renderingThread->EmplaceTask(std::forward<F>(command), std::forward<Args>(args)...);
-    }
-}
diff --git a/Engine/Source/Render/Include/Render/RenderThread.h b/Engine/Source/Render/Include/Render/RenderThread.h
new file mode 100644
index 000000000..114992bae
--- /dev/null
+++ b/Engine/Source/Render/Include/Render/RenderThread.h
@@ -0,0 +1,78 @@
+//
+// Created by johnk on 2025/2/11.
+//
+
+#pragma once
+
+#include <Common/Memory.h>
+#include <Common/Concurrent.h>
+#include <Core/Thread.h>
+
+namespace Render {
+    class RenderThread {
+    public:
+        static RenderThread& Get();
+
+        ~RenderThread();
+
+        void Start();
+        void Stop();
+        void Flush() const;
+        template <typename F, typename... Args> auto EmplaceTask(F&& inTask, Args&&... inArgs);
+
+    private:
+        RenderThread();
+
+        Common::UniquePtr<Common::WorkerThread> thread;
+    };
+
+    class RenderWorkerThreads {
+    public:
+        static RenderWorkerThreads& Get();
+
+        ~RenderWorkerThreads();
+
+        void Start();
+        void Stop();
+        template <typename F, typename... Args> auto EmplaceTask(F&& inTask, Args&&... inArgs);
+        template <typename F, typename... Args> void ExecuteTasks(size_t inTaskNum, F&& inTask, Args&&... inArgs);
+
+    private:
+        RenderWorkerThreads();
+
+        Common::UniquePtr<Common::ThreadPool> threads;
+    };
+}
+
+namespace Render {
+    template <typename F, typename ... Args>
+    auto RenderThread::EmplaceTask(F&& inTask, Args&&... inArgs)
+    {
+        Assert(thread != nullptr);
+        return thread->EmplaceTask(std::forward<F>(inTask), std::forward<Args>(inArgs)...);
+    }
+
+    template <typename F, typename ... Args>
+    auto RenderWorkerThreads::EmplaceTask(F&& inTask, Args&&... inArgs)
+    {
+        using RetType = std::invoke_result_t<F, Args...>;
+
+        Assert(threads != nullptr);
+        auto packedTask = std::bind(std::forward<F>(inTask), std::forward<Args>(inArgs)...);
+        return threads->EmplaceTask([packedTask]() -> RetType {
+            Core::ThreadContext::SetTag(Core::ThreadTag::renderWorker);
+            return packedTask();
+        });
+    }
+
+    template <typename F, typename ... Args>
+    void RenderWorkerThreads::ExecuteTasks(size_t inTaskNum, F&& inTask, Args&&... inArgs)
+    {
+        Assert(threads != nullptr);
+        auto packedTask = std::bind(std::forward<F>(inTask), std::placeholders::_1, std::forward<Args>(inArgs)...);
+        threads->ExecuteTasks(inTaskNum, [packedTask](size_t inIndex) -> void {
+            Core::ThreadContext::SetTag(Core::ThreadTag::renderWorker);
+            packedTask(inIndex);
+        });
+    }
+}
diff --git a/Engine/Source/Render/Include/Render/ResourcePool.h b/Engine/Source/Render/Include/Render/ResourcePool.h
index db4dd2d38..5b5920177 100644
--- a/Engine/Source/Render/Include/Render/ResourcePool.h
+++ b/Engine/Source/Render/Include/Render/ResourcePool.h
@@ -20,14 +20,14 @@ namespace Render {
     public:
         using DescType = typename RHIResTraits<RHIRes>::DescType;
 
-        explicit PooledResource(Common::UniqueRef<RHIRes>&& inRhiHandle, DescType inDesc);
+        explicit PooledResource(Common::UniquePtr<RHIRes>&& inRhiHandle, DescType inDesc);
         ~PooledResource();
 
         RHIRes* GetRHI() const;
         const DescType& GetDesc() const;
 
     private:
-        Common::UniqueRef<RHIRes> rhiHandle;
+        Common::UniquePtr<RHIRes> rhiHandle;
         DescType desc;
     };
 
@@ -35,32 +35,33 @@ namespace Render {
     using PooledTexture = PooledResource<RHI::Texture>;
     using PooledBufferDesc = RHI::BufferCreateInfo;
     using PooledTextureDesc = RHI::TextureCreateInfo;
-    using PooledBufferRef = Common::SharedRef<PooledBuffer>;
-    using PooledTextureRef = Common::SharedRef<PooledTexture>;
+    using PooledBufferRef = Common::SharedPtr<PooledBuffer>;
+    using PooledTextureRef = Common::SharedPtr<PooledTexture>;
 
     template <typename PooledRes>
     struct PooledResTraits {};
 
     template <typename PooledRes>
-    class RGResourcePool {
+    class ResourcePool {
     public:
         using ResRefType = typename PooledResTraits<PooledRes>::RefType;
         using DescType = typename PooledResTraits<PooledRes>::DescType;
 
-        static RGResourcePool& Get(RHI::Device& device);
+        static ResourcePool& Get(RHI::Device& device);
 
         ResRefType Allocate(const DescType& desc);
-        void GarbageCollect();
+        size_t Size() const;
+        void Tick();
 
     private:
-        explicit RGResourcePool(RHI::Device& inDevice);
+        explicit ResourcePool(RHI::Device& inDevice);
 
         RHI::Device& device;
-        std::vector<ResRefType> pooledResources;
+        std::vector<std::pair<ResRefType, uint32_t>> pooledResourceAndAges;
     };
 
-    using BufferPool = RGResourcePool<PooledBuffer>;
-    using TexturePool = RGResourcePool<PooledTexture>;
+    using BufferPool = ResourcePool<PooledBuffer>;
+    using TexturePool = ResourcePool<PooledTexture>;
 }
 
 namespace Render {
@@ -75,7 +76,7 @@ namespace Render {
     };
 
     template <typename RHIResource>
-    PooledResource<RHIResource>::PooledResource(Common::UniqueRef<RHIResource>&& inRhiHandle, DescType inDesc)
+    PooledResource<RHIResource>::PooledResource(Common::UniquePtr<RHIResource>&& inRhiHandle, DescType inDesc)
         : rhiHandle(std::move(inRhiHandle))
         , desc(std::move(inDesc))
     {
@@ -121,41 +122,56 @@ namespace Render {
     };
 
     template <typename PooledResource>
-    RGResourcePool<PooledResource>& RGResourcePool<PooledResource>::Get(RHI::Device& device)
+    ResourcePool<PooledResource>& ResourcePool<PooledResource>::Get(RHI::Device& device)
     {
-        static std::unordered_map<RHI::Device*, Common::UniqueRef<RGResourcePool>> deviceMap;
+        static std::unordered_map<RHI::Device*, Common::UniquePtr<ResourcePool>> deviceMap;
         if (!deviceMap.contains(&device)) {
-            deviceMap.emplace(std::make_pair(&device, Common::UniqueRef<RGResourcePool>(new RGResourcePool(device))));
+            deviceMap.emplace(std::make_pair(&device, Common::UniquePtr<ResourcePool>(new ResourcePool(device))));
         }
         return *deviceMap.at(&device);
     }
 
     template <typename PooledResource>
-    RGResourcePool<PooledResource>::RGResourcePool(RHI::Device& inDevice)
+    ResourcePool<PooledResource>::ResourcePool(RHI::Device& inDevice)
         : device(inDevice)
     {
     }
 
     template <typename PooledResource>
-    typename RGResourcePool<PooledResource>::ResRefType RGResourcePool<PooledResource>::Allocate(const DescType& desc)
+    typename ResourcePool<PooledResource>::ResRefType ResourcePool<PooledResource>::Allocate(const DescType& desc)
     {
-        for (const auto& pooledResource : pooledResources) {
+        for (auto& [pooledResource, age] : pooledResourceAndAges) {
             if (pooledResource.RefCount() == 1 && desc == pooledResource->GetDesc()) {
+                age = 0;
                 return pooledResource;
             }
         }
         auto result = PooledResTraits<PooledResource>::CreateResource(device, desc);
-        pooledResources.push_back(result);
+        pooledResourceAndAges.emplace_back(result, 0);
         return result;
     }
 
     template <typename PooledRes>
-    void RGResourcePool<PooledRes>::GarbageCollect()
+    size_t ResourcePool<PooledRes>::Size() const
     {
-        // TODO maybe we need add a age check ? >= 2 frame not be used == need release
-        for (auto i = 0; i < pooledResources.size();) {
-            if (pooledResources[i].RefCount() <= 1) {
-                pooledResources.erase(pooledResources.begin() + i);
+        return pooledResourceAndAges.size();
+    }
+
+    template <typename PooledRes>
+    void ResourcePool<PooledRes>::Tick()
+    {
+        for (auto i = 0; i < pooledResourceAndAges.size();) {
+            bool needRelease = false;
+            auto& [pooledResource, age] = pooledResourceAndAges[i];
+
+            if (pooledResource.RefCount() <= 1) {
+                needRelease = ++age >= 2;
+            } else {
+                age = 0;
+            }
+
+            if (needRelease) { // NOLINT
+                pooledResourceAndAges.erase(pooledResourceAndAges.begin() + i);
             } else {
                 i++;
             }
diff --git a/Engine/Source/Render/Include/Render/Shader.h b/Engine/Source/Render/Include/Render/Shader.h
index 84c142eeb..b991d53ca 100644
--- a/Engine/Source/Render/Include/Render/Shader.h
+++ b/Engine/Source/Render/Include/Render/Shader.h
@@ -148,7 +148,7 @@ namespace Render {
 
         [[nodiscard]] const ShaderArchive& GetArchive(const typename T::VariantSet& variantSet) const;
 
-        std::unordered_map<RHI::Device*, std::unordered_map<VariantKey, Common::UniqueRef<RHI::ShaderModule>>> shaderModules;
+        std::unordered_map<RHI::Device*, std::unordered_map<VariantKey, Common::UniquePtr<RHI::ShaderModule>>> shaderModules;
     };
 
     class GlobalShaderRegistry {
@@ -263,7 +263,7 @@ namespace Render {
     class VariantSet : public Render::VariantSetImpl<__VA_ARGS__> {};
 
 #define NonVariant \
-    RangedIntShaderVariantField(_PlaceholderVariantField, "__PLACEHOLDER_VARIANT", 0, 0); \
+    RangedIntShaderVariantField(_PlaceholderVariantField, "__PLACEHOLDER_VARIANT", 0, 0); /* NOLINT */ \
     VariantSet(_PlaceholderVariantField);
 
 #define RegisterGlobalShader(inClass) \
diff --git a/Engine/Source/Render/SharedSrc/RenderModule.cpp b/Engine/Source/Render/SharedSrc/RenderModule.cpp
index f446befc6..b37ff2c8a 100644
--- a/Engine/Source/Render/SharedSrc/RenderModule.cpp
+++ b/Engine/Source/Render/SharedSrc/RenderModule.cpp
@@ -34,8 +34,8 @@ namespace Render {
     {
         Assert(!initialized);
 
-        renderingThread = Common::MakeUnique<Common::WorkerThread>("RenderingThread");
-        renderingThread->EmplaceTask([]() -> void { Core::ThreadContext::SetTag(Core::ThreadTag::render); });
+        RenderThread::Get().Start();
+        RenderWorkerThreads::Get().Start();
 
         rhiInstance = RHI::Instance::GetByType(inParams.rhiType);
         rhiDevice = rhiInstance->GetGpu(0)->RequestDevice(
@@ -49,7 +49,9 @@ namespace Render {
 
     void RenderModule::DeInitialize()
     {
-        renderingThread = nullptr;
+        RenderThread::Get().Stop();
+        RenderWorkerThreads::Get().Stop();
+
         rhiInstance = nullptr;
         rhiDevice = nullptr;
         initialized = false;
@@ -60,25 +62,19 @@ namespace Render {
         return rhiDevice.Get();
     }
 
-    Common::UniqueRef<Render::Scene> RenderModule::NewScene() // NOLINT
-    {
-        return new Scene();
-    }
-
-    Common::UniqueRef<View> RenderModule::NewView() // NOLINT
+    Render::RenderThread& RenderModule::GetRenderThread() const // NOLINT
     {
-        return new View();
+        return RenderThread::Get();
     }
 
-    void RenderModule::ShutdownRenderingThread()
+    Common::UniquePtr<Render::Scene> RenderModule::NewScene() // NOLINT
     {
-        renderingThread = nullptr;
+        return new Scene();
     }
 
-    void RenderModule::FlushAllRenderingCommands() const
+    Common::UniquePtr<View> RenderModule::NewView() // NOLINT
     {
-        Assert(renderingThread != nullptr);
-        renderingThread->Flush();
+        return new View();
     }
 }
 
diff --git a/Engine/Source/Render/Src/RenderCache.cpp b/Engine/Source/Render/Src/RenderCache.cpp
index a451847e3..ce68b0245 100644
--- a/Engine/Source/Render/Src/RenderCache.cpp
+++ b/Engine/Source/Render/Src/RenderCache.cpp
@@ -22,7 +22,7 @@ namespace Render {
             auto hash = desc.Hash();
             auto iter = pipelineLayouts.find(hash);
             if (iter == pipelineLayouts.end()) {
-                pipelineLayouts[hash] = Common::UniqueRef<PipelineLayout>(new PipelineLayout(device, desc, hash));
+                pipelineLayouts[hash] = Common::UniquePtr<PipelineLayout>(new PipelineLayout(device, desc, hash));
             }
             return pipelineLayouts[hash].Get();
         }
@@ -31,16 +31,16 @@ namespace Render {
         explicit PipelineLayoutCache(RHI::Device& inDevice);
 
         RHI::Device& device;
-        std::unordered_map<size_t, Common::UniqueRef<PipelineLayout>> pipelineLayouts;
+        std::unordered_map<size_t, Common::UniquePtr<PipelineLayout>> pipelineLayouts;
     };
 
     PipelineLayoutCache& PipelineLayoutCache::Get(RHI::Device& device)
     {
-        static std::unordered_map<RHI::Device*, Common::UniqueRef<PipelineLayoutCache>> map;
+        static std::unordered_map<RHI::Device*, Common::UniquePtr<PipelineLayoutCache>> map;
 
         if (const auto iter = map.find(&device);
             iter == map.end()) {
-            map[&device] = Common::UniqueRef(new PipelineLayoutCache(device));
+            map[&device] = Common::UniquePtr(new PipelineLayoutCache(device));
         }
         return *map[&device];
     }
@@ -389,7 +389,7 @@ namespace Render {
             BindGroupLayoutDesc desc;
             desc.layoutIndex = layoutIndex;
             desc.binding = binding;
-            bindGroupLayouts[layoutIndex] = Common::UniqueRef(new BindGroupLayout(device, desc));
+            bindGroupLayouts[layoutIndex] = Common::UniquePtr(new BindGroupLayout(device, desc));
         }
     }
 
@@ -500,11 +500,11 @@ namespace Render {
 
     SamplerCache& SamplerCache::Get(RHI::Device& device)
     {
-        static std::unordered_map<RHI::Device*, Common::UniqueRef<SamplerCache>> map;
+        static std::unordered_map<RHI::Device*, Common::UniquePtr<SamplerCache>> map;
 
         const auto iter = map.find(&device);
         if (iter == map.end()) {
-            map[&device] = Common::UniqueRef(new SamplerCache(device));
+            map[&device] = Common::UniquePtr(new SamplerCache(device));
         }
         return *map[&device];
     }
@@ -521,18 +521,18 @@ namespace Render {
         const size_t hash = Common::HashUtils::CityHash(&desc, sizeof(RSamplerDesc));
         if (const auto iter = samplers.find(hash);
             iter == samplers.end()) {
-            samplers[hash] = Common::UniqueRef(new Sampler(device, desc));
+            samplers[hash] = Common::UniquePtr(new Sampler(device, desc));
         }
         return samplers[hash].Get();
     }
 
     PipelineCache& PipelineCache::Get(RHI::Device& device)
     {
-        static std::unordered_map<RHI::Device*, Common::UniqueRef<PipelineCache>> map;
+        static std::unordered_map<RHI::Device*, Common::UniquePtr<PipelineCache>> map;
 
         if (const auto iter = map.find(&device);
             iter == map.end()) {
-            map[&device] = Common::UniqueRef(new PipelineCache(device));
+            map[&device] = Common::UniquePtr(new PipelineCache(device));
         }
         return *map[&device];
     }
@@ -556,7 +556,7 @@ namespace Render {
         const auto hash = desc.Hash();
         if (const auto iter = computePipelines.find(hash);
             iter == computePipelines.end()) {
-            computePipelines[hash] = Common::UniqueRef(new ComputePipelineState(device, desc, hash));
+            computePipelines[hash] = Common::UniquePtr(new ComputePipelineState(device, desc, hash));
         }
         return computePipelines[hash].Get();
     }
@@ -566,17 +566,17 @@ namespace Render {
         const auto hash = desc.Hash();
         if (const auto iter = rasterPipelines.find(hash);
             iter == rasterPipelines.end()) {
-            rasterPipelines[hash] = Common::UniqueRef(new RasterPipelineState(device, desc, hash));
+            rasterPipelines[hash] = Common::UniquePtr(new RasterPipelineState(device, desc, hash));
         }
         return rasterPipelines[hash].Get();
     }
 
     ResourceViewCache& ResourceViewCache::Get(RHI::Device& device)
     {
-        static std::unordered_map<RHI::Device*, Common::UniqueRef<ResourceViewCache>> map;
+        static std::unordered_map<RHI::Device*, Common::UniquePtr<ResourceViewCache>> map;
 
         if (!map.contains(&device)) {
-            map.emplace(std::make_pair(&device, Common::UniqueRef(new ResourceViewCache(device))));
+            map.emplace(std::make_pair(&device, Common::UniquePtr(new ResourceViewCache(device))));
         }
         return *map.at(&device);
     }
@@ -617,7 +617,7 @@ namespace Render {
         auto hash = inDesc.Hash();
         if (const auto iter = views.find(hash);
             iter == views.end()) {
-            views.emplace(std::make_pair(hash, Common::UniqueRef(buffer->CreateBufferView(inDesc))));
+            views.emplace(std::make_pair(hash, Common::UniquePtr(buffer->CreateBufferView(inDesc))));
         }
         return views.at(hash).Get();
     }
@@ -629,7 +629,7 @@ namespace Render {
         auto hash = inDesc.Hash();
         if (const auto iter = views.find(hash);
             iter == views.end()) {
-            views.emplace(std::make_pair(hash, Common::UniqueRef(texture->CreateTextureView(inDesc))));
+            views.emplace(std::make_pair(hash, Common::UniquePtr(texture->CreateTextureView(inDesc))));
         }
         return views.at(hash).Get();
     }
diff --git a/Engine/Source/Render/Src/RenderGraph.cpp b/Engine/Source/Render/Src/RenderGraph.cpp
index e56ab767e..374967242 100644
--- a/Engine/Source/Render/Src/RenderGraph.cpp
+++ b/Engine/Source/Render/Src/RenderGraph.cpp
@@ -5,22 +5,23 @@
 #include <ranges>
 
 #include <Render/RenderGraph.h>
+#include <Render/RenderThread.h>
 #include <Common/Container.h>
 
 namespace Render::Internal {
     static void ComputeReadsWritesForBindGroup(const RGBindGroupDesc& inDesc, std::unordered_set<RGResourceRef>& outReads, std::unordered_set<RGResourceRef>& outWrites)
     {
-        for (const auto& [name, item] : inDesc.items) {
-            if (item.type == RHI::BindingType::uniformBuffer) {
-                outReads.emplace(std::get<RGBufferViewRef>(item.view)->GetResource());
-            } else if (item.type == RHI::BindingType::storageBuffer) {
-                outReads.emplace(std::get<RGBufferViewRef>(item.view)->GetResource());
-            } else if (item.type == RHI::BindingType::rwStorageBuffer) {
-                outWrites.emplace(std::get<RGBufferViewRef>(item.view)->GetResource());
-            } else if (item.type == RHI::BindingType::texture) {
-                outReads.emplace(std::get<RGTextureViewRef>(item.view)->GetResource());
-            } else if (item.type == RHI::BindingType::storageTexture) {
-                outWrites.emplace(std::get<RGTextureViewRef>(item.view)->GetResource());
+        for (const auto& [type, view] : inDesc.items | std::views::values) {
+            if (type == RHI::BindingType::uniformBuffer) {
+                outReads.emplace(std::get<RGBufferViewRef>(view)->GetResource());
+            } else if (type == RHI::BindingType::storageBuffer) {
+                outReads.emplace(std::get<RGBufferViewRef>(view)->GetResource());
+            } else if (type == RHI::BindingType::rwStorageBuffer) {
+                outWrites.emplace(std::get<RGBufferViewRef>(view)->GetResource());
+            } else if (type == RHI::BindingType::texture) {
+                outReads.emplace(std::get<RGTextureViewRef>(view)->GetResource());
+            } else if (type == RHI::BindingType::storageTexture) {
+                outWrites.emplace(std::get<RGTextureViewRef>(view)->GetResource());
             } else {
                 Unimplement();
             }
@@ -275,6 +276,17 @@ namespace Render {
         return *this;
     }
 
+    RGBindGroupDesc& RGBindGroupDesc::RwStorageBuffer(std::string inName, RGBufferViewRef bufferView)
+    {
+        Assert(!items.contains(inName));
+
+        RGBindItemDesc item;
+        item.type = RHI::BindingType::rwStorageBuffer;
+        item.view = bufferView;
+        items.emplace(std::make_pair(std::move(inName), item));
+        return *this;
+    }
+
     RGBindGroupDesc& RGBindGroupDesc::Texture(std::string inName, RGTextureViewRef textureView)
     {
         Assert(!items.contains(inName));
@@ -309,6 +321,22 @@ namespace Render {
         return desc;
     }
 
+    RGBufferUploadInfo::RGBufferUploadInfo()
+        : data(nullptr)
+        , size(0)
+        , srcOffset(0)
+        , dstOffset(0)
+    {
+    }
+
+    RGBufferUploadInfo::RGBufferUploadInfo(void* inData, size_t inSize, size_t inSrcOffset, size_t inDstOffset)
+        : data(inData)
+        , size(inSize)
+        , srcOffset(inSrcOffset)
+        , dstOffset(inDstOffset)
+    {
+    }
+
     RGPass::RGPass(std::string inName, RGPassType inType)
         : name(std::move(inName))
         , type(inType)
@@ -317,29 +345,35 @@ namespace Render {
 
     RGPass::~RGPass() = default;
 
-    RGCopyPass::RGCopyPass(std::string inName, RGCopyPassDesc inPassDesc, RGCopyPassExecuteFunc inFunc)
+    RGCopyPass::RGCopyPass(std::string inName, RGCopyPassDesc inPassDesc, RGCopyPassExecuteFunc inFunc, RGCommonPassExecuteFunc inPreExecuteFunc, RGCommonPassExecuteFunc inPostExecuteFunc)
         : RGPass(std::move(inName), RGPassType::copy)
         , passDesc(std::move(inPassDesc))
-        , func(std::move(inFunc))
+        , passFunc(std::move(inFunc))
+        , prePassFunc(std::move(inPreExecuteFunc))
+        , postPassFunc(std::move(inPostExecuteFunc))
     {
     }
 
     RGCopyPass::~RGCopyPass() = default;
 
-    RGComputePass::RGComputePass(std::string inName, std::vector<RGBindGroupRef> inBindGroups, RGComputePassExecuteFunc inFunc)
+    RGComputePass::RGComputePass(std::string inName, std::vector<RGBindGroupRef> inBindGroups, RGComputePassExecuteFunc inFunc, RGCommonPassExecuteFunc inPreExecuteFunc, RGCommonPassExecuteFunc inPostExecuteFunc)
         : RGPass(std::move(inName), RGPassType::compute)
-        , func(std::move(inFunc))
+        , passFunc(std::move(inFunc))
+        , prePassFunc(std::move(inPreExecuteFunc))
+        , postPassFunc(std::move(inPostExecuteFunc))
         , bindGroups(std::move(inBindGroups))
     {
     }
 
     RGComputePass::~RGComputePass() = default;
 
-    RGRasterPass::RGRasterPass(std::string inName, RGRasterPassDesc inPassDesc, std::vector<RGBindGroupRef> inBindGroupds, RGRasterPassExecuteFunc inFunc)
+    RGRasterPass::RGRasterPass(std::string inName, RGRasterPassDesc inPassDesc, std::vector<RGBindGroupRef> inBindGroups, RGRasterPassExecuteFunc inFunc, RGCommonPassExecuteFunc inPreExecuteFunc, RGCommonPassExecuteFunc inPostExecuteFunc)
         : RGPass(std::move(inName), RGPassType::raster)
         , passDesc(std::move(inPassDesc))
-        , bindGroups(std::move(inBindGroupds))
-        , func(std::move(inFunc))
+        , passFunc(std::move(inFunc))
+        , prePassFunc(std::move(inPreExecuteFunc))
+        , postPassFunc(std::move(inPostExecuteFunc))
+        , bindGroups(std::move(inBindGroups))
     {
     }
 
@@ -408,24 +442,30 @@ namespace Render {
         return bindGroups.back().Get();
     }
 
-    void RGBuilder::AddCopyPass(const std::string& inName, const RGCopyPassDesc& inPassDesc, const RGCopyPassExecuteFunc& inFunc, bool inAsyncCopy)
+    void RGBuilder::QueueBufferUpload(RGBufferRef inBuffer, const RGBufferUploadInfo& inUploadInfo)
+    {
+        Assert((inBuffer->GetDesc().usages & RHI::BufferUsageBits::mapWrite) != RHI::BufferUsageFlags::null);
+        bufferUploads.emplace(inBuffer, inUploadInfo);
+    }
+
+    void RGBuilder::AddCopyPass(const std::string& inName, const RGCopyPassDesc& inPassDesc, const RGCopyPassExecuteFunc& inFunc, bool inAsyncCopy, const RGCommonPassExecuteFunc& inPreExecuteFunc, const RGCommonPassExecuteFunc& inPostExecuteFunc)
     {
         Assert(!executed);
-        const auto& pass = passes.emplace_back(new RGCopyPass(inName, inPassDesc, inFunc));
+        const auto& pass = passes.emplace_back(new RGCopyPass(inName, inPassDesc, inFunc, inPreExecuteFunc, inPostExecuteFunc));
         recordingAsyncTimeline[inAsyncCopy ? RGQueueType::asyncCopy : RGQueueType::main].emplace_back(pass.Get());
     }
 
-    void RGBuilder::AddComputePass(const std::string& inName, const std::vector<RGBindGroupRef>& inBindGroups, const RGComputePassExecuteFunc& inFunc, bool inAsyncCompute)
+    void RGBuilder::AddComputePass(const std::string& inName, const std::vector<RGBindGroupRef>& inBindGroups, const RGComputePassExecuteFunc& inFunc, bool inAsyncCompute, const RGCommonPassExecuteFunc& inPreExecuteFunc, const RGCommonPassExecuteFunc& inPostExecuteFunc)
     {
         Assert(!executed);
-        const auto& pass = passes.emplace_back(new RGComputePass(inName, inBindGroups, inFunc));
+        const auto& pass = passes.emplace_back(new RGComputePass(inName, inBindGroups, inFunc, inPreExecuteFunc, inPostExecuteFunc));
         recordingAsyncTimeline[inAsyncCompute ? RGQueueType::asyncCompute : RGQueueType::main].emplace_back(pass.Get());
     }
 
-    void RGBuilder::AddRasterPass(const std::string& inName, const RGRasterPassDesc& inPassDesc, const std::vector<RGBindGroupRef>& inBindGroupds, const RGRasterPassExecuteFunc& inFunc)
+    void RGBuilder::AddRasterPass(const std::string& inName, const RGRasterPassDesc& inPassDesc, const std::vector<RGBindGroupRef>& inBindGroups, const RGRasterPassExecuteFunc& inFunc, const RGCommonPassExecuteFunc& inPreExecuteFunc, const RGCommonPassExecuteFunc& inPostExecuteFunc)
     {
         Assert(!executed);
-        const auto& pass = passes.emplace_back(new RGRasterPass(inName, inPassDesc, inBindGroupds, inFunc));
+        const auto& pass = passes.emplace_back(new RGRasterPass(inName, inPassDesc, inBindGroups, inFunc, inPreExecuteFunc, inPostExecuteFunc));
         recordingAsyncTimeline[RGQueueType::main].emplace_back(pass.Get());
     }
 
@@ -509,11 +549,13 @@ namespace Render {
 
     void RGBuilder::ExecuteInternal(const RGExecuteInfo& inExecuteInfo) // NOLINT
     {
+        PerformBufferUploads();
         DevirtualizeViewsCreatedOnImportedResources();
 
         const auto asyncTimelineNum = asyncTimelines.size();
         asyncTimelineExecuteContexts.reserve(asyncTimelineNum);
 
+        WaitBufferUploadsFinish();
         for (const auto& queuePasses : asyncTimelines) {
             const bool isFirstAsyncTimeline = asyncTimelineExecuteContexts.empty();
             const bool isLastAsyncTimeline = asyncTimelineExecuteContexts.size() + 1 == asyncTimelines.size();
@@ -527,7 +569,7 @@ namespace Render {
             } else {
                 // wait all cmd buffers in last async timeline executed
                 for (const AsyncTimelineExecuteContext& lastContext = asyncTimelineExecuteContexts.back();
-                    const auto& [queue, semaphore] : lastContext.queueSemaphoreToSignalMap) {
+                    const auto& semaphore : lastContext.queueSemaphoreToSignalMap | std::views::values) {
                     semaphoresToWait.emplace_back(semaphore.Get());
                 }
             }
@@ -656,7 +698,7 @@ namespace Render {
             queueReadsVec.reserve(queuePasses.size());
             queueWritesVec.reserve(queuePasses.size());
 
-            for (const auto& [queueType, passes] : queuePasses) {
+            for (const auto& passes : queuePasses | std::views::values) {
                 auto& queueReads = queueReadsVec.emplace_back();
                 auto& queueWrites = queueWritesVec.emplace_back();
                 collectQueueReadWrites(passes, queueReads, queueWrites);
@@ -739,11 +781,17 @@ namespace Render {
         DevirtualizeResources(passWritesMap.at(inCopyPass));
         {
             TransitionResourcesForCopyPassDesc(inRecoder, inCopyPass->passDesc);
+            if (inCopyPass->prePassFunc) {
+                inCopyPass->prePassFunc(*this, inRecoder);
+            }
             {
                 const auto copyPassRecoder = inRecoder.BeginCopyPass();
-                inCopyPass->func(*this, *copyPassRecoder);
+                inCopyPass->passFunc(*this, *copyPassRecoder);
                 copyPassRecoder->EndPass();
             }
+            if (inCopyPass->postPassFunc) {
+                inCopyPass->postPassFunc(*this, inRecoder);
+            }
         }
         FinalizePassResources(passReadsMap.at(inCopyPass));
     }
@@ -754,11 +802,17 @@ namespace Render {
         DevirtualizeBindGroupsAndViews(inComputePass->bindGroups);
         {
             TransitionResourcesForBindGroups(inRecoder, inComputePass->bindGroups);
+            if (inComputePass->prePassFunc) {
+                inComputePass->prePassFunc(*this, inRecoder);
+            }
             {
                 const auto computePassRecoder = inRecoder.BeginComputePass();
-                inComputePass->func(*this, *computePassRecoder);
+                inComputePass->passFunc(*this, *computePassRecoder);
                 computePassRecoder->EndPass();
             }
+            if (inComputePass->postPassFunc) {
+                inComputePass->postPassFunc(*this, inRecoder);
+            }
         }
         FinalizePassResources(passReadsMap.at(inComputePass));
         FinalizePassBindGroups(inComputePass->bindGroups);
@@ -772,16 +826,45 @@ namespace Render {
         {
             TransitionResourcesForBindGroups(inRecoder, inRasterPass->bindGroups);
             TransitionResourcesForRasterPassDesc(inRecoder, inRasterPass->passDesc);
+            if (inRasterPass->prePassFunc) {
+                inRasterPass->prePassFunc(*this, inRecoder);
+            }
             {
                 const auto rasterPassRecoder = inRecoder.BeginRasterPass(Internal::GetRHIRasterPassBeginInfo(*this, inRasterPass->passDesc));
-                inRasterPass->func(*this, *rasterPassRecoder);
+                inRasterPass->passFunc(*this, *rasterPassRecoder);
                 rasterPassRecoder->EndPass();
             }
+            if (inRasterPass->postPassFunc) {
+                inRasterPass->postPassFunc(*this, inRecoder);
+            }
         }
         FinalizePassResources(passReadsMap.at(inRasterPass));
         FinalizePassBindGroups(inRasterPass->bindGroups);
     }
 
+    void RGBuilder::PerformBufferUploads()
+    {
+        bufferUploadTasks.reserve(bufferUploads.size());
+        for (const auto& [buffer, uploadInfo] : bufferUploads) {
+            DevirtualizeResource(buffer);
+            auto* rhiBuffer = GetRHI(buffer);
+
+            bufferUploadTasks.emplace_back(RenderWorkerThreads::Get().EmplaceTask([rhiBuffer, uploadInfo]() -> void {
+                const auto* src = static_cast<const uint8_t*>(uploadInfo.data) + uploadInfo.srcOffset;
+                auto* dst = rhiBuffer->Map(RHI::MapMode::write, uploadInfo.dstOffset, uploadInfo.size);
+                memcpy(dst, src, uploadInfo.size);
+                rhiBuffer->UnMap();
+            }));
+        }
+    }
+
+    void RGBuilder::WaitBufferUploadsFinish() const
+    {
+        for (const auto& task : bufferUploadTasks) {
+            task.wait();
+        }
+    }
+
     void RGBuilder::DevirtualizeViewsCreatedOnImportedResources()
     {
         for (const auto& view : views) {
@@ -804,22 +887,27 @@ namespace Render {
         }
     }
 
+    void RGBuilder::DevirtualizeResource(RGResourceRef inResource)
+    {
+        if (inResource->imported
+            || culledResources.contains(inResource)
+            || devirtualizedResources.contains(inResource)) {
+            return;
+        }
+
+        if (inResource->type == RGResType::buffer) {
+            devirtualizedResources.emplace(std::make_pair(inResource, BufferPool::Get(device).Allocate(static_cast<RGBufferRef>(inResource)->desc)));
+        } else if (inResource->type == RGResType::texture) {
+            devirtualizedResources.emplace(std::make_pair(inResource, TexturePool::Get(device).Allocate(static_cast<RGTextureRef>(inResource)->desc)));
+        } else {
+            Unimplement();
+        }
+    }
+
     void RGBuilder::DevirtualizeResources(const std::unordered_set<RGResourceRef>& inResources)
     {
         for (auto* resource : inResources) {
-            if (resource->imported
-                || culledResources.contains(resource)
-                || devirtualizedResources.contains(resource)) {
-                continue;
-            }
-
-            if (resource->type == RGResType::buffer) {
-                devirtualizedResources.emplace(std::make_pair(resource, BufferPool::Get(device).Allocate(static_cast<RGBufferRef>(resource)->desc)));
-            } else if (resource->type == RGResType::texture) {
-                devirtualizedResources.emplace(std::make_pair(resource, TexturePool::Get(device).Allocate(static_cast<RGTextureRef>(resource)->desc)));
-            } else {
-                Unimplement();
-            }
+            DevirtualizeResource(resource);
         }
     }
 
@@ -833,7 +921,7 @@ namespace Render {
                 const auto* binding = layout->GetBinding(name);
                 Assert(binding != nullptr);
 
-                if (item.type == RHI::BindingType::uniformBuffer || item.type == RHI::BindingType::storageBuffer) {
+                if (item.type == RHI::BindingType::uniformBuffer || item.type == RHI::BindingType::storageBuffer || item.type == RHI::BindingType::rwStorageBuffer) {
                     auto* bufferView = std::get<RGBufferViewRef>(item.view);
                     if (!devirtualizedResourceViews.contains(bufferView)) {
                         devirtualizedResourceViews.emplace(std::make_pair(bufferView, ResourceViewCache::Get(device).GetOrCreate(GetRHI(bufferView->GetBuffer()), bufferView->desc)));
@@ -931,16 +1019,18 @@ namespace Render {
     void RGBuilder::TransitionResourcesForBindGroups(RHI::CommandCommandRecorder& inRecoder, const std::vector<RGBindGroupRef>& inBindGroups)
     {
         for (auto* bindGroup : inBindGroups) {
-            for (const auto& [name, item] : bindGroup->desc.items) {
-                if (item.type == RHI::BindingType::uniformBuffer) {
-                    TransitionBuffer(inRecoder, std::get<RGBufferViewRef>(item.view)->GetBuffer(), RHI::BufferState::shaderReadOnly);
-                } else if (item.type == RHI::BindingType::storageBuffer) {
-                    TransitionBuffer(inRecoder, std::get<RGBufferViewRef>(item.view)->GetBuffer(), RHI::BufferState::storage);
-                } else if (item.type == RHI::BindingType::texture) {
-                    TransitionTexture(inRecoder, std::get<RGTextureViewRef>(item.view)->GetTexture(), RHI::TextureState::shaderReadOnly);
-                } else if (item.type == RHI::BindingType::storageTexture) {
-                    TransitionTexture(inRecoder, std::get<RGTextureViewRef>(item.view)->GetTexture(), RHI::TextureState::storage);
-                } else if (item.type == RHI::BindingType::sampler) {} else {
+            for (const auto& [type, view] : bindGroup->desc.items | std::views::values) {
+                if (type == RHI::BindingType::uniformBuffer) {
+                    TransitionBuffer(inRecoder, std::get<RGBufferViewRef>(view)->GetBuffer(), RHI::BufferState::shaderReadOnly);
+                } else if (type == RHI::BindingType::storageBuffer) {
+                    TransitionBuffer(inRecoder, std::get<RGBufferViewRef>(view)->GetBuffer(), RHI::BufferState::storage);
+                } else if (type == RHI::BindingType::rwStorageBuffer) {
+                    TransitionBuffer(inRecoder, std::get<RGBufferViewRef>(view)->GetBuffer(), RHI::BufferState::rwStorage);
+                } else if (type == RHI::BindingType::texture) {
+                    TransitionTexture(inRecoder, std::get<RGTextureViewRef>(view)->GetTexture(), RHI::TextureState::shaderReadOnly);
+                } else if (type == RHI::BindingType::storageTexture) {
+                    TransitionTexture(inRecoder, std::get<RGTextureViewRef>(view)->GetTexture(), RHI::TextureState::storage);
+                } else if (type == RHI::BindingType::sampler) {} else {
                     Unimplement();
                 }
             }
diff --git a/Engine/Source/Render/Src/RenderThread.cpp b/Engine/Source/Render/Src/RenderThread.cpp
new file mode 100644
index 000000000..9333ff6c2
--- /dev/null
+++ b/Engine/Source/Render/Src/RenderThread.cpp
@@ -0,0 +1,58 @@
+//
+// Created by johnk on 2025/2/11.
+//
+
+#include <Render/RenderThread.h>
+
+namespace Render {
+    RenderThread& RenderThread::Get()
+    {
+        static RenderThread instance;
+        return instance;
+    }
+
+    RenderThread::RenderThread() = default;
+
+    RenderThread::~RenderThread() = default;
+
+    void RenderThread::Start()
+    {
+        Assert(thread == nullptr);
+        thread = Common::MakeUnique<Common::WorkerThread>("RenderingThread");
+        thread->EmplaceTask([]() -> void { Core::ThreadContext::SetTag(Core::ThreadTag::render); });
+    }
+
+    void RenderThread::Stop()
+    {
+        Assert(thread != nullptr);
+        thread = nullptr;
+    }
+
+    void RenderThread::Flush() const
+    {
+        Assert(thread != nullptr);
+        thread->Flush();
+    }
+
+    RenderWorkerThreads& RenderWorkerThreads::Get()
+    {
+        static RenderWorkerThreads instance;
+        return instance;
+    }
+
+    RenderWorkerThreads::RenderWorkerThreads() = default;
+
+    RenderWorkerThreads::~RenderWorkerThreads() = default;
+
+    void RenderWorkerThreads::Start()
+    {
+        Assert(threads == nullptr);
+        threads = Common::MakeUnique<Common::ThreadPool>("RenderWorkers", 8);
+    }
+
+    void RenderWorkerThreads::Stop()
+    {
+        Assert(threads != nullptr);
+        threads = nullptr;
+    }
+}
diff --git a/Engine/Source/Render/Src/ShaderCompiler.cpp b/Engine/Source/Render/Src/ShaderCompiler.cpp
index 5cbbfa39e..d8422cacc 100644
--- a/Engine/Source/Render/Src/ShaderCompiler.cpp
+++ b/Engine/Source/Render/Src/ShaderCompiler.cpp
@@ -332,11 +332,11 @@ namespace Render {
 
     std::future<ShaderCompileOutput> ShaderCompiler::Compile(const ShaderCompileInput& inInput, const ShaderCompileOptions& inOptions)
     {
-        return threadPool.EmplaceTask([](const ShaderCompileInput& input, const ShaderCompileOptions& options) -> ShaderCompileOutput {
+        return threadPool.EmplaceTask([inInput, inOptions]() -> ShaderCompileOutput {
             ShaderCompileOutput output;
-            CompileDxilOrSpriv(input, options, output);
+            CompileDxilOrSpriv(inInput, inOptions, output);
             return output;
-        }, inInput, inOptions);
+        });
     }
 
     ShaderTypeCompiler& ShaderTypeCompiler::Get()
@@ -354,10 +354,10 @@ namespace Render {
 
     std::future<ShaderTypeCompileResult> ShaderTypeCompiler::Compile(const std::vector<IShaderType*>& inShaderTypes, const ShaderCompileOptions& inOptions)
     {
-        return threadPool.EmplaceTask([](const std::vector<IShaderType*>& shaderTypes, const ShaderCompileOptions& options) -> ShaderTypeCompileResult {
+        return threadPool.EmplaceTask([inShaderTypes, inOptions]() -> ShaderTypeCompileResult {
             std::unordered_map<ShaderTypeKey, std::unordered_map<VariantKey, std::future<ShaderCompileOutput>>> compileOutputs;
-            compileOutputs.reserve(shaderTypes.size());
-            for (auto* shaderType : shaderTypes) {
+            compileOutputs.reserve(inShaderTypes.size());
+            for (auto* shaderType : inShaderTypes) {
                 auto typeKey = shaderType->GetKey();
                 auto stage = shaderType->GetStage();
                 const auto& entryPoint = shaderType->GetEntryPoint();
@@ -375,7 +375,7 @@ namespace Render {
                     input.stage = stage;
                     input.definitions = shaderType->GetDefinitions(variantKey);
 
-                    variantCompileOutputs.emplace(std::make_pair(variantKey, ShaderCompiler::Get().Compile(input, options)));
+                    variantCompileOutputs.emplace(std::make_pair(variantKey, ShaderCompiler::Get().Compile(input, inOptions)));
                 }
             }
 
@@ -399,7 +399,7 @@ namespace Render {
             }
             result.success = result.errorInfos.empty();
             return result;
-        }, inShaderTypes, inOptions);
+        });
     }
 
     std::future<ShaderTypeCompileResult> ShaderTypeCompiler::CompileGlobalShaderTypes(const ShaderCompileOptions& inOptions)
diff --git a/Engine/Source/Render/Test/ResourcePoolTest.cpp b/Engine/Source/Render/Test/ResourcePoolTest.cpp
index fc51f11b0..6045f3fd2 100644
--- a/Engine/Source/Render/Test/ResourcePoolTest.cpp
+++ b/Engine/Source/Render/Test/ResourcePoolTest.cpp
@@ -21,7 +21,7 @@ struct ResourcePoolTest : testing::Test {
     void TearDown() override {}
 
     RHI::Instance* instance;
-    Common::UniqueRef<RHI::Device> device;
+    Common::UniquePtr<RHI::Device> device;
 };
 
 TEST_F(ResourcePoolTest, BasicTest)
@@ -38,22 +38,34 @@ TEST_F(ResourcePoolTest, BasicTest)
     textureDesc.samples = 1;
     textureDesc.initialState = RHI::TextureState::undefined;
     PooledTextureRef t1 = texturePool.Allocate(textureDesc);
+    ASSERT_EQ(texturePool.Size(), 1);
 
     textureDesc.width = 1024;
     textureDesc.height = 1024;
     textureDesc.depthOrArraySize = 1;
     PooledTextureRef t2 = texturePool.Allocate(textureDesc);
+    ASSERT_EQ(texturePool.Size(), 2);
 
     textureDesc.width = 1920;
     textureDesc.height = 1080;
     textureDesc.depthOrArraySize = 1;
-    const PooledTextureRef t3 = texturePool.Allocate(textureDesc);
+    PooledTextureRef t3 = texturePool.Allocate(textureDesc);
     ASSERT_NE(t1.Get(), t3.Get());
+    ASSERT_EQ(texturePool.Size(), 3);
 
     auto* texturePtr = t1.Get();
     t1.Reset();
     const PooledTextureRef t4 = texturePool.Allocate(textureDesc);
     ASSERT_EQ(texturePtr, t4.Get());
+    ASSERT_EQ(texturePool.Size(), 3);
 
-    texturePool.GarbageCollect();
+    t2.Reset();
+    t3.Reset();
+    ASSERT_EQ(texturePool.Size(), 3);
+
+    texturePool.Tick();
+    ASSERT_EQ(texturePool.Size(), 3);
+
+    texturePool.Tick();
+    ASSERT_EQ(texturePool.Size(), 1);
 }
diff --git a/Engine/Source/Runtime/Include/Runtime/Asset.h b/Engine/Source/Runtime/Include/Runtime/Asset.h
index c8de6d6d8..dacf7c808 100644
--- a/Engine/Source/Runtime/Include/Runtime/Asset.h
+++ b/Engine/Source/Runtime/Include/Runtime/Asset.h
@@ -29,21 +29,21 @@ namespace Runtime {
     };
 
     template <Common::DerivedFrom<Asset> A>
-    class AssetRef {
+    class AssetPtr {
     public:
-        template <Common::DerivedFrom<Asset> A2> AssetRef(Common::SharedRef<A2>& inRef); // NOLINT
-        template <Common::DerivedFrom<Asset> A2> AssetRef(Common::SharedRef<A2>&& inRef) noexcept; // NOLINT
-        AssetRef(A* pointer); // NOLINT
-        AssetRef(AssetRef& other); // NOLINT
-        AssetRef(AssetRef&& other) noexcept; // NOLINT
-        AssetRef();
-        ~AssetRef();
-
-        template <Common::DerivedFrom<Asset> A2> AssetRef& operator=(Common::SharedRef<A2>& inRef);
-        template <Common::DerivedFrom<Asset> A2> AssetRef& operator=(Common::SharedRef<A2>&& inRef) noexcept;
-        AssetRef& operator=(A* pointer);
-        AssetRef& operator=(AssetRef& other); // NOLINT
-        AssetRef& operator=(AssetRef&& other) noexcept;
+        template <Common::DerivedFrom<Asset> A2> AssetPtr(Common::SharedPtr<A2>& sharedPtr); // NOLINT
+        template <Common::DerivedFrom<Asset> A2> AssetPtr(Common::SharedPtr<A2>&& sharedPtr) noexcept; // NOLINT
+        AssetPtr(A* pointer); // NOLINT
+        AssetPtr(AssetPtr& other); // NOLINT
+        AssetPtr(AssetPtr&& other) noexcept; // NOLINT
+        AssetPtr();
+        ~AssetPtr();
+
+        template <Common::DerivedFrom<Asset> A2> AssetPtr& operator=(Common::SharedPtr<A2>& sharedPtr);
+        template <Common::DerivedFrom<Asset> A2> AssetPtr& operator=(Common::SharedPtr<A2>&& sharedPtr) noexcept;
+        AssetPtr& operator=(A* pointer);
+        AssetPtr& operator=(AssetPtr& other); // NOLINT
+        AssetPtr& operator=(AssetPtr&& other) noexcept;
 
         const Core::Uri& Uri() const;
         A* operator->() const noexcept;
@@ -53,60 +53,60 @@ namespace Runtime {
         A* Get() const;
         void Reset(A* pointer = nullptr);
         auto RefCount() const;
-        Common::SharedRef<A>& GetSharedRef();
-        template <Common::DerivedFrom<Asset> A2> AssetRef<A2> StaticCast();
-        template <Common::DerivedFrom<Asset> A2> AssetRef<A2> DynamicCast();
-        template <Common::DerivedFrom<Asset> A2> AssetRef<A2> ReinterpretCast();
+        Common::SharedPtr<A>& GetSharedRef();
+        template <Common::DerivedFrom<Asset> A2> AssetPtr<A2> StaticCast();
+        template <Common::DerivedFrom<Asset> A2> AssetPtr<A2> DynamicCast();
+        template <Common::DerivedFrom<Asset> A2> AssetPtr<A2> ReinterpretCast();
 
     private:
-        Common::SharedRef<A> ref;
+        Common::SharedPtr<A> ptr;
     };
 
     template <Common::DerivedFrom<Asset> A>
-    class WeakAssetRef {
+    class WeakAssetPtr {
     public:
-        template <Common::DerivedFrom<Asset> A2> WeakAssetRef(AssetRef<A2>& inRef); // NOLINT
-        WeakAssetRef(WeakAssetRef& other); // NOLINT
-        WeakAssetRef(WeakAssetRef&& other) noexcept; // NOLINT
+        template <Common::DerivedFrom<Asset> A2> WeakAssetPtr(AssetPtr<A2>& assetPtr); // NOLINT
+        WeakAssetPtr(WeakAssetPtr& other); // NOLINT
+        WeakAssetPtr(WeakAssetPtr&& other) noexcept; // NOLINT
 
-        template <Common::DerivedFrom<Asset> A2> WeakAssetRef& operator=(AssetRef<A2>& inRef);
-        WeakAssetRef& operator=(WeakAssetRef& other); // NOLINT
-        WeakAssetRef& operator=(WeakAssetRef&& other) noexcept;
+        template <Common::DerivedFrom<Asset> A2> WeakAssetPtr& operator=(AssetPtr<A2>& assetPtr);
+        WeakAssetPtr& operator=(WeakAssetPtr& other); // NOLINT
+        WeakAssetPtr& operator=(WeakAssetPtr&& other) noexcept;
         void Reset();
         bool Expired() const;
-        AssetRef<A> Lock() const;
+        AssetPtr<A> Lock() const;
 
     private:
-        Common::WeakRef<A> ref;
+        Common::WeakPtr<A> ptr;
     };
 
     template <Common::DerivedFrom<Asset> A>
-    class SoftAssetRef {
+    class SoftAssetPtr {
     public:
-        SoftAssetRef();
-        explicit SoftAssetRef(Core::Uri inUri);
-        explicit SoftAssetRef(AssetRef<A>& inAsset);
-        SoftAssetRef(const SoftAssetRef<A>& other);
-        SoftAssetRef(SoftAssetRef<A>&& other) noexcept;
-        ~SoftAssetRef();
-
-        SoftAssetRef& operator=(Core::Uri inUri);
-        SoftAssetRef& operator=(AssetRef<A>& inAsset);
-        SoftAssetRef& operator=(const SoftAssetRef<A>& other);
-        SoftAssetRef& operator=(SoftAssetRef<A>&& other) noexcept;
+        SoftAssetPtr();
+        explicit SoftAssetPtr(Core::Uri inUri);
+        explicit SoftAssetPtr(AssetPtr<A>& inAsset);
+        SoftAssetPtr(const SoftAssetPtr<A>& other);
+        SoftAssetPtr(SoftAssetPtr<A>&& other) noexcept;
+        ~SoftAssetPtr();
+
+        SoftAssetPtr& operator=(Core::Uri inUri);
+        SoftAssetPtr& operator=(AssetPtr<A>& inAsset);
+        SoftAssetPtr& operator=(const SoftAssetPtr<A>& other);
+        SoftAssetPtr& operator=(SoftAssetPtr<A>&& other) noexcept;
 
         bool Empty() const;
         bool Loaded() const;
-        AssetRef<A> Get() const;
+        AssetPtr<A> Get() const;
         void Reset();
         const Core::Uri& Uri() const;
 
     private:
         Core::Uri uri;
-        AssetRef<A> asset;
+        AssetPtr<A> asset;
     };
 
-    template <Common::DerivedFrom<Asset> A> using OnAssetLoaded = std::function<void(AssetRef<A>)>;
+    template <Common::DerivedFrom<Asset> A> using OnAssetLoaded = std::function<void(AssetPtr<A>)>;
     template <Common::DerivedFrom<Asset> A> using OnSoftAssetLoaded = std::function<void()>;
 
     class RUNTIME_API AssetManager {
@@ -114,35 +114,35 @@ namespace Runtime {
         static AssetManager& Get();
         ~AssetManager();
 
-        template <Common::DerivedFrom<Asset> A> AssetRef<A> SyncLoad(const Core::Uri& uri);
-        template <Common::DerivedFrom<Asset> A> void SyncLoadSoft(SoftAssetRef<A>& softAssetRef);
+        template <Common::DerivedFrom<Asset> A> AssetPtr<A> SyncLoad(const Core::Uri& uri);
+        template <Common::DerivedFrom<Asset> A> void SyncLoadSoft(SoftAssetPtr<A>& softAssetRef);
         template <Common::DerivedFrom<Asset> A> void AsyncLoad(const Core::Uri& uri, const OnAssetLoaded<A>& onAssetLoaded);
-        template <Common::DerivedFrom<Asset> A> void AsyncLoadSoft(SoftAssetRef<A>& softAssetRef, const OnSoftAssetLoaded<A>& onSoftAssetLoaded);
-        template <Common::DerivedFrom<Asset> A> void Save(const AssetRef<A>& assetRef);
-        template <Common::DerivedFrom<Asset> A> void SaveSoft(const SoftAssetRef<A>& softAssetRef);
+        template <Common::DerivedFrom<Asset> A> void AsyncLoadSoft(SoftAssetPtr<A>& softAssetRef, const OnSoftAssetLoaded<A>& onSoftAssetLoaded);
+        template <Common::DerivedFrom<Asset> A> void Save(const AssetPtr<A>& assetRef);
+        template <Common::DerivedFrom<Asset> A> void SaveSoft(const SoftAssetPtr<A>& softAssetRef);
 
     private:
-        template <Common::DerivedFrom<Asset> A> AssetRef<A> LoadInternal(const Core::Uri& uri);
+        template <Common::DerivedFrom<Asset> A> AssetPtr<A> LoadInternal(const Core::Uri& uri);
 
         AssetManager();
 
         std::mutex mutex;
-        std::unordered_map<Core::Uri, WeakAssetRef<Asset>> weakAssetRefs;
+        std::unordered_map<Core::Uri, WeakAssetPtr<Asset>> weakAssetRefs;
         Common::ThreadPool threadPool;
     };
 }
 
 namespace Common {
     template <DerivedFrom<Runtime::Asset> A>
-    struct Serializer<Runtime::AssetRef<A>> {
+    struct Serializer<Runtime::AssetPtr < A>> {
         static constexpr size_t typeId = Common::HashUtils::StrCrc32("Runtime::AssetRef");
 
-        static size_t Serialize(BinarySerializeStream& stream, const Runtime::AssetRef<A>& value)
+        static size_t Serialize(BinarySerializeStream& stream, const Runtime::AssetPtr<A>& value)
         {
             return Serializer<Core::Uri>::Serialize(stream, value);
         }
 
-        static size_t Deserialize(BinaryDeserializeStream& stream, Runtime::AssetRef<A>& value)
+        static size_t Deserialize(BinaryDeserializeStream& stream, Runtime::AssetPtr<A>& value)
         {
             Core::Uri uri;
             const auto deserialized = Serializer<Core::Uri>::Deserialize(stream, uri);
@@ -152,15 +152,15 @@ namespace Common {
     };
 
     template <DerivedFrom<Runtime::Asset> A>
-    struct Serializer<Runtime::SoftAssetRef<A>> {
+    struct Serializer<Runtime::SoftAssetPtr<A>> {
         static constexpr size_t typeId = Common::HashUtils::StrCrc32("Runtime::SoftAssetRef");
 
-        static size_t Serialize(BinarySerializeStream& stream, const Runtime::SoftAssetRef<A>& value)
+        static size_t Serialize(BinarySerializeStream& stream, const Runtime::SoftAssetPtr<A>& value)
         {
             return Serializer<Core::Uri>::Serialize(stream, value);
         }
 
-        static size_t Deserialize(BinaryDeserializeStream& stream, Runtime::SoftAssetRef<A>& value)
+        static size_t Deserialize(BinaryDeserializeStream& stream, Runtime::SoftAssetPtr<A>& value)
         {
             Core::Uri uri;
             const auto deserialized = Serializer<Core::Uri>::Deserialize(stream, uri);
@@ -173,254 +173,254 @@ namespace Common {
 namespace Runtime {
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A>::AssetRef(Common::SharedRef<A2>& inRef)
-        : ref(inRef)
+    AssetPtr<A>::AssetPtr(Common::SharedPtr<A2>& sharedPtr)
+        : ptr(sharedPtr)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A>::AssetRef(Common::SharedRef<A2>&& inRef) noexcept
-        : ref(std::move(inRef))
+    AssetPtr<A>::AssetPtr(Common::SharedPtr<A2>&& sharedPtr) noexcept
+        : ptr(std::move(sharedPtr))
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>::AssetRef(A* pointer)
-        : ref(pointer)
+    AssetPtr<A>::AssetPtr(A* pointer)
+        : ptr(pointer)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>::AssetRef(AssetRef& other)
-        : ref(other.ref)
+    AssetPtr<A>::AssetPtr(AssetPtr& other)
+        : ptr(other.ptr)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>::AssetRef(AssetRef&& other) noexcept
-        : ref(std::move(other.ref))
+    AssetPtr<A>::AssetPtr(AssetPtr&& other) noexcept
+        : ptr(std::move(other.ptr))
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>::AssetRef() = default;
+    AssetPtr<A>::AssetPtr() = default;
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>::~AssetRef() = default;
+    AssetPtr<A>::~AssetPtr() = default;
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A>& AssetRef<A>::operator=(Common::SharedRef<A2>& inRef)
+    AssetPtr<A>& AssetPtr<A>::operator=(Common::SharedPtr<A2>& sharedPtr)
     {
-        ref = inRef;
+        ptr = sharedPtr;
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A>& AssetRef<A>::operator=(Common::SharedRef<A2>&& inRef) noexcept
+    AssetPtr<A>& AssetPtr<A>::operator=(Common::SharedPtr<A2>&& sharedPtr) noexcept
     {
-        ref = inRef;
+        ptr = sharedPtr;
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>& AssetRef<A>::operator=(A* pointer)
+    AssetPtr<A>& AssetPtr<A>::operator=(A* pointer)
     {
-        ref = pointer;
+        ptr = pointer;
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>& AssetRef<A>::operator=(AssetRef& other)
+    AssetPtr<A>& AssetPtr<A>::operator=(AssetPtr& other)
     {
-        ref = other.ref;
+        ptr = other.ptr;
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A>& AssetRef<A>::operator=(AssetRef&& other) noexcept
+    AssetPtr<A>& AssetPtr<A>::operator=(AssetPtr&& other) noexcept
     {
-        ref = std::move(other.ref);
+        ptr = std::move(other.ptr);
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    const Core::Uri& AssetRef<A>::Uri() const
+    const Core::Uri& AssetPtr<A>::Uri() const
     {
-        Assert(ref != nullptr);
-        return ref->uri;
+        Assert(ptr != nullptr);
+        return ptr->uri;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    A* AssetRef<A>::operator->() const noexcept
+    A* AssetPtr<A>::operator->() const noexcept
     {
-        return ref.operator->();
+        return ptr.operator->();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    A& AssetRef<A>::operator*() const noexcept
+    A& AssetPtr<A>::operator*() const noexcept
     {
-        return ref.operator*();
+        return ptr.operator*();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    bool AssetRef<A>::operator==(nullptr_t) const noexcept
+    bool AssetPtr<A>::operator==(nullptr_t) const noexcept
     {
-        return ref == nullptr;
+        return ptr == nullptr;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    bool AssetRef<A>::operator!=(nullptr_t) const noexcept
+    bool AssetPtr<A>::operator!=(nullptr_t) const noexcept
     {
-        return ref != nullptr;
+        return ptr != nullptr;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    A* AssetRef<A>::Get() const
+    A* AssetPtr<A>::Get() const
     {
-        return ref.Get();
+        return ptr.Get();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void AssetRef<A>::Reset(A* pointer)
+    void AssetPtr<A>::Reset(A* pointer)
     {
-        ref.Reset(pointer);
+        ptr.Reset(pointer);
     }
 
     template <Common::DerivedFrom<Asset> A>
-    auto AssetRef<A>::RefCount() const
+    auto AssetPtr<A>::RefCount() const
     {
-        return ref.RefCount();
+        return ptr.RefCount();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    Common::SharedRef<A>& AssetRef<A>::GetSharedRef()
+    Common::SharedPtr<A>& AssetPtr<A>::GetSharedRef()
     {
-        return ref;
+        return ptr;
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A2> AssetRef<A>::StaticCast()
+    AssetPtr<A2> AssetPtr<A>::StaticCast()
     {
-        return ref.template StaticCast<A2>();
+        return ptr.template StaticCast<A2>();
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A2> AssetRef<A>::DynamicCast()
+    AssetPtr<A2> AssetPtr<A>::DynamicCast()
     {
-        return ref.template DynamicCast<A2>();
+        return ptr.template DynamicCast<A2>();
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    AssetRef<A2> AssetRef<A>::ReinterpretCast()
+    AssetPtr<A2> AssetPtr<A>::ReinterpretCast()
     {
-        return ref.template ReinterpretCast<A2>();
+        return ptr.template ReinterpretCast<A2>();
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    WeakAssetRef<A>::WeakAssetRef(AssetRef<A2>& inRef)
-        : ref(inRef.GetSharedRef())
+    WeakAssetPtr<A>::WeakAssetPtr(AssetPtr<A2>& assetPtr)
+        : ptr(assetPtr.GetSharedRef())
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    WeakAssetRef<A>::WeakAssetRef(WeakAssetRef& other)
-        : ref(other.ref)
+    WeakAssetPtr<A>::WeakAssetPtr(WeakAssetPtr& other)
+        : ptr(other.ptr)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    WeakAssetRef<A>::WeakAssetRef(WeakAssetRef&& other) noexcept
-        : ref(std::move(other.ref))
+    WeakAssetPtr<A>::WeakAssetPtr(WeakAssetPtr&& other) noexcept
+        : ptr(std::move(other.ptr))
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
     template <Common::DerivedFrom<Asset> A2>
-    WeakAssetRef<A>& WeakAssetRef<A>::operator=(AssetRef<A2>& inRef)
+    WeakAssetPtr<A>& WeakAssetPtr<A>::operator=(AssetPtr<A2>& assetPtr)
     {
-        ref = inRef.GetSharedRef();
+        ptr = assetPtr.GetSharedRef();
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    WeakAssetRef<A>& WeakAssetRef<A>::operator=(WeakAssetRef& other)
+    WeakAssetPtr<A>& WeakAssetPtr<A>::operator=(WeakAssetPtr& other)
     {
-        ref = other.ref;
+        ptr = other.ptr;
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    WeakAssetRef<A>& WeakAssetRef<A>::operator=(WeakAssetRef&& other) noexcept
+    WeakAssetPtr<A>& WeakAssetPtr<A>::operator=(WeakAssetPtr&& other) noexcept
     {
-        ref = std::move(other.ref);
+        ptr = std::move(other.ptr);
         return *this;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void WeakAssetRef<A>::Reset()
+    void WeakAssetPtr<A>::Reset()
     {
-        ref.Reset();
+        ptr.Reset();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    bool WeakAssetRef<A>::Expired() const
+    bool WeakAssetPtr<A>::Expired() const
     {
-        return ref.Expired();
+        return ptr.Expired();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A> WeakAssetRef<A>::Lock() const
+    AssetPtr<A> WeakAssetPtr<A>::Lock() const
     {
-        return ref.Lock();
+        return ptr.Lock();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::SoftAssetRef()
+    SoftAssetPtr<A>::SoftAssetPtr()
         : uri()
         , asset()
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::SoftAssetRef(Core::Uri inUri)
+    SoftAssetPtr<A>::SoftAssetPtr(Core::Uri inUri)
         : uri(std::move(inUri))
         , asset()
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::SoftAssetRef(AssetRef<A>& inAsset)
+    SoftAssetPtr<A>::SoftAssetPtr(AssetPtr<A>& inAsset)
         : uri(inAsset.Uri())
         , asset(inAsset)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::SoftAssetRef(const SoftAssetRef<A>& other)
+    SoftAssetPtr<A>::SoftAssetPtr(const SoftAssetPtr<A>& other)
         : uri(other.uri)
         , asset(other.asset)
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::SoftAssetRef(SoftAssetRef<A>&& other) noexcept
+    SoftAssetPtr<A>::SoftAssetPtr(SoftAssetPtr<A>&& other) noexcept
         : uri(std::move(other.uri))
         , asset(std::move(other.asset))
     {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>::~SoftAssetRef() = default;
+    SoftAssetPtr<A>::~SoftAssetPtr() = default;
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>& SoftAssetRef<A>::operator=(Core::Uri inUri)
+    SoftAssetPtr<A>& SoftAssetPtr<A>::operator=(Core::Uri inUri)
     {
         uri = std::move(inUri);
         asset = nullptr;
@@ -428,7 +428,7 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>& SoftAssetRef<A>::operator=(AssetRef<A>& inAsset)
+    SoftAssetPtr<A>& SoftAssetPtr<A>::operator=(AssetPtr<A>& inAsset)
     {
         uri = inAsset.Uri();
         asset = inAsset;
@@ -436,7 +436,7 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>& SoftAssetRef<A>::operator=(const SoftAssetRef<A>& other)
+    SoftAssetPtr<A>& SoftAssetPtr<A>::operator=(const SoftAssetPtr<A>& other)
     {
         uri = other.uri;
         asset = other.asset;
@@ -444,7 +444,7 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    SoftAssetRef<A>& SoftAssetRef<A>::operator=(SoftAssetRef<A>&& other) noexcept
+    SoftAssetPtr<A>& SoftAssetPtr<A>::operator=(SoftAssetPtr<A>&& other) noexcept
     {
         uri = std::move(other.uri);
         asset = std::move(other.asset);
@@ -452,47 +452,47 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    bool SoftAssetRef<A>::Empty() const
+    bool SoftAssetPtr<A>::Empty() const
     {
         return uri.Empty();
     }
 
     template <Common::DerivedFrom<Asset> A>
-    bool SoftAssetRef<A>::Loaded() const
+    bool SoftAssetPtr<A>::Loaded() const
     {
         return asset != nullptr;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A> SoftAssetRef<A>::Get() const
+    AssetPtr<A> SoftAssetPtr<A>::Get() const
     {
         return asset;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void SoftAssetRef<A>::Reset()
+    void SoftAssetPtr<A>::Reset()
     {
         asset = nullptr;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    const Core::Uri& SoftAssetRef<A>::Uri() const
+    const Core::Uri& SoftAssetPtr<A>::Uri() const
     {
         return uri;
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A> AssetManager::SyncLoad(const Core::Uri& uri)
+    AssetPtr<A> AssetManager::SyncLoad(const Core::Uri& uri)
     {
         auto iter = weakAssetRefs.find(uri);
         if (iter != weakAssetRefs.end() && !iter->second.Expired()) {
             return iter->second.Lock().StaticCast<A>();
         }
 
-        AssetRef<A> result = LoadInternal<A>(uri);
-        AssetRef<Asset> tempRef = result.template StaticCast<Asset>();
+        AssetPtr<A> result = LoadInternal<A>(uri);
+        AssetPtr<Asset> tempRef = result.template StaticCast<Asset>();
         if (iter == weakAssetRefs.end()) {
-            weakAssetRefs.emplace(std::make_pair(uri, WeakAssetRef<Asset>(tempRef)));
+            weakAssetRefs.emplace(std::make_pair(uri, WeakAssetPtr<Asset>(tempRef)));
         } else {
             iter->second = tempRef;
         }
@@ -500,7 +500,7 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void AssetManager::SyncLoadSoft(SoftAssetRef<A>& softAssetRef)
+    void AssetManager::SyncLoadSoft(SoftAssetPtr<A>& softAssetRef)
     {
         softAssetRef = SyncLoad<A>(softAssetRef.Uri());
     }
@@ -509,7 +509,7 @@ namespace Runtime {
     void AssetManager::AsyncLoad(const Core::Uri& uri, const OnAssetLoaded<A>& onAssetLoaded)
     {
         threadPool.EmplaceTask([=]() -> void {
-            AssetRef<A> result = nullptr;
+            AssetPtr<A> result = nullptr;
             {
                 std::unique_lock<std::mutex> lock(mutex);
                 auto iter = weakAssetRefs.find(uri);
@@ -522,12 +522,12 @@ namespace Runtime {
                 result = LoadInternal<A>(uri);
             }
 
-            AssetRef<Asset> tempRef = result.template StaticCast<Asset>();
+            AssetPtr<Asset> tempRef = result.template StaticCast<Asset>();
             {
                 std::unique_lock<std::mutex> lock(mutex);
                 auto iter = weakAssetRefs.find(uri);
                 if (iter == weakAssetRefs.end()) {
-                    weakAssetRefs.emplace(std::make_pair(uri, WeakAssetRef<Asset>(tempRef)));
+                    weakAssetRefs.emplace(std::make_pair(uri, WeakAssetPtr<Asset>(tempRef)));
                 } else {
                     iter->second = tempRef;
                 }
@@ -538,10 +538,10 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void AssetManager::AsyncLoadSoft(SoftAssetRef<A>& softAssetRef, const OnSoftAssetLoaded<A>& onSoftAssetLoaded)
+    void AssetManager::AsyncLoadSoft(SoftAssetPtr<A>& softAssetRef, const OnSoftAssetLoaded<A>& onSoftAssetLoaded)
     {
         threadPool.EmplaceTask([this, softAssetRef, onSoftAssetLoaded]() -> void {
-            AsyncLoad(softAssetRef.Uri(), [&](AssetRef<A>& ref) -> void {
+            AsyncLoad(softAssetRef.Uri(), [&](AssetPtr<A>& ref) -> void {
                 softAssetRef = ref;
                 onSoftAssetLoaded();
             });
@@ -549,7 +549,7 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void AssetManager::Save(const AssetRef<A>& assetRef)
+    void AssetManager::Save(const AssetPtr<A>& assetRef)
     {
         if (assetRef == nullptr) {
             return;
@@ -564,19 +564,19 @@ namespace Runtime {
     }
 
     template <Common::DerivedFrom<Asset> A>
-    void AssetManager::SaveSoft(const SoftAssetRef<A>& softAssetRef)
+    void AssetManager::SaveSoft(const SoftAssetPtr<A>& softAssetRef)
     {
         Save(softAssetRef.Uri());
     }
 
     template <Common::DerivedFrom<Asset> A>
-    AssetRef<A> AssetManager::LoadInternal(const Core::Uri& uri)
+    AssetPtr<A> AssetManager::LoadInternal(const Core::Uri& uri)
     {
         Core::AssetUriParser parser(uri);
         auto pathString = parser.AbsoluteFilePath().String();
         Common::BinaryFileDeserializeStream stream(pathString);
 
-        AssetRef<A> result = Common::SharedRef<A>(new A());
+        AssetPtr<A> result = Common::SharedPtr<A>(new A());
         Mirror::Any ref = std::ref(*result.Get());
         ref.Deserialize(stream);
 
diff --git a/Engine/Source/Runtime/Include/Runtime/ECS.h b/Engine/Source/Runtime/Include/Runtime/ECS.h
index 5719ccbef..4da239072 100644
--- a/Engine/Source/Runtime/Include/Runtime/ECS.h
+++ b/Engine/Source/Runtime/Include/Runtime/ECS.h
@@ -143,7 +143,7 @@ namespace Runtime::Internal {
     class SystemFactory {
     public:
         explicit SystemFactory(SystemClass inClass);
-        Common::UniqueRef<System> Build(ECRegistry& inRegistry) const;
+        Common::UniquePtr<System> Build(ECRegistry& inRegistry) const;
         std::unordered_map<std::string, Mirror::Any> GetArguments();
         const std::unordered_map<std::string, Mirror::Any>& GetArguments() const;
         SystemClass GetClass() const;
@@ -595,7 +595,7 @@ namespace Runtime {
     private:
         struct SystemContext {
             const Internal::SystemFactory& factory;
-            Common::UniqueRef<System> instance;
+            Common::UniquePtr<System> instance;
         };
 
         struct SystemGroupContext {
diff --git a/Engine/Source/Runtime/Include/Runtime/Engine.h b/Engine/Source/Runtime/Include/Runtime/Engine.h
index 97427f0bf..80fa5c3a9 100644
--- a/Engine/Source/Runtime/Include/Runtime/Engine.h
+++ b/Engine/Source/Runtime/Include/Runtime/Engine.h
@@ -30,7 +30,7 @@ namespace Runtime {
         void UnmountWorld(World* inWorld);
         Render::RenderModule& GetRenderModule() const;
         void Tick(float inDeltaTimeSeconds) const;
-        Common::UniqueRef<World> CreateWorld(const std::string& inName = "") const;
+        Common::UniquePtr<World> CreateWorld(const std::string& inName = "") const;
 
     protected:
         explicit Engine(const EngineInitParams& inParams);
@@ -61,6 +61,6 @@ namespace Runtime {
         static Engine& Get();
 
     private:
-        static Common::UniqueRef<Engine> engine;
+        static Common::UniquePtr<Engine> engine;
     };
 }
diff --git a/Engine/Source/Runtime/Include/Runtime/System/Scene.h b/Engine/Source/Runtime/Include/Runtime/System/Scene.h
index b5f38fbce..bc87448c6 100644
--- a/Engine/Source/Runtime/Include/Runtime/System/Scene.h
+++ b/Engine/Source/Runtime/Include/Runtime/System/Scene.h
@@ -34,7 +34,7 @@ namespace Runtime {
         void RemoveLightSceneProxy(Entity e);
 
         Render::RenderModule& renderModule;
-        Common::UniqueRef<Render::Scene> scene;
+        Common::UniquePtr<Render::Scene> scene;
         Observer transformUpdatedObserver;
         EventsObserver<DirectionalLight> directionalLightsObserver;
         EventsObserver<PointLight> pointLightsObserver;
diff --git a/Engine/Source/Runtime/Src/ECS.cpp b/Engine/Source/Runtime/Src/ECS.cpp
index d5572c519..1b6f1e29f 100644
--- a/Engine/Source/Runtime/Src/ECS.cpp
+++ b/Engine/Source/Runtime/Src/ECS.cpp
@@ -344,7 +344,7 @@ namespace Runtime::Internal {
         BuildArgumentLists();
     }
 
-    Common::UniqueRef<System> SystemFactory::Build(ECRegistry& inRegistry) const
+    Common::UniquePtr<System> SystemFactory::Build(ECRegistry& inRegistry) const
     {
         const Mirror::Any system = clazz->New(inRegistry);
         const Mirror::Any systemRef = system.Deref();
diff --git a/Engine/Source/Runtime/Src/Engine.cpp b/Engine/Source/Runtime/Src/Engine.cpp
index 288217b55..d9376716d 100644
--- a/Engine/Source/Runtime/Src/Engine.cpp
+++ b/Engine/Source/Runtime/Src/Engine.cpp
@@ -58,7 +58,7 @@ namespace Runtime {
         // TODO emplace render thread task, like wait fence, console command copy
     }
 
-    Common::UniqueRef<World> Engine::CreateWorld(const std::string& inName) const // NOLINT
+    Common::UniquePtr<World> Engine::CreateWorld(const std::string& inName) const // NOLINT
     {
         return new World(inName);
     }
@@ -84,7 +84,7 @@ namespace Runtime {
         LogInfo(Render, "RHI type: {}", inRhiTypeStr);
     }
 
-    Common::UniqueRef<Engine> EngineHolder::engine = nullptr;
+    Common::UniquePtr<Engine> EngineHolder::engine = nullptr;
 
     MinEngine::MinEngine(const EngineInitParams& inParams)
         : Engine(inParams)
diff --git a/Engine/Source/Runtime/Test/AssetTest.cpp b/Engine/Source/Runtime/Test/AssetTest.cpp
index 651c5af19..5348e58c2 100644
--- a/Engine/Source/Runtime/Test/AssetTest.cpp
+++ b/Engine/Source/Runtime/Test/AssetTest.cpp
@@ -8,14 +8,14 @@
 
 TEST(AssetTest, AssetRefTest0)
 {
-    AssetRef<TestAsset> a0 = MakeShared<TestAsset>();
+    AssetPtr<TestAsset> a0 = MakeShared<TestAsset>();
     ASSERT_EQ(a0.RefCount(), 1);
 
-    AssetRef<TestAsset> a1 = a0;
+    AssetPtr<TestAsset> a1 = a0;
     ASSERT_EQ(a0.RefCount(), 2);
     ASSERT_EQ(a1.RefCount(), 2);
 
-    AssetRef<Asset> a2 = a1.StaticCast<Asset>();
+    AssetPtr<Asset> a2 = a1.StaticCast<Asset>();
     ASSERT_EQ(a0.RefCount(), 3);
     ASSERT_EQ(a1.RefCount(), 3);
     ASSERT_EQ(a2.RefCount(), 3);
@@ -23,15 +23,15 @@ TEST(AssetTest, AssetRefTest0)
 
 TEST(AssetTest, AssetRefTest1)
 {
-    AssetRef<TestAsset> a0 = MakeShared<TestAsset>();
-    AssetRef<TestAsset> a1 = std::move(a0);
+    AssetPtr<TestAsset> a0 = MakeShared<TestAsset>();
+    AssetPtr<TestAsset> a1 = std::move(a0);
     ASSERT_EQ(a1.RefCount(), 1);
 
-    WeakAssetRef<TestAsset> w0 = a1;
+    WeakAssetPtr<TestAsset> w0 = a1;
     ASSERT_FALSE(w0.Expired());
 
-    AssetRef<Asset> a2 = a1.StaticCast<Asset>();
-    WeakAssetRef<Asset> w1 = a2;
+    AssetPtr<Asset> a2 = a1.StaticCast<Asset>();
+    WeakAssetPtr<Asset> w1 = a2;
     ASSERT_FALSE(w1.Expired());
 
     a1.Reset();
@@ -44,10 +44,10 @@ TEST(AssetTest, SaveLoadTest)
 {
     static Core::Uri uri("asset://Engine/Test/Generated/Runtime/AssetTest.SaveLoadTest");
 
-    AssetRef<TestAsset> asset = MakeShared<TestAsset>(uri, 1, "hello");
+    AssetPtr<TestAsset> asset = MakeShared<TestAsset>(uri, 1, "hello");
     AssetManager::Get().Save(asset);
 
-    AssetRef<TestAsset> restore = AssetManager::Get().SyncLoad<TestAsset>(uri);
+    AssetPtr<TestAsset> restore = AssetManager::Get().SyncLoad<TestAsset>(uri);
     ASSERT_EQ(restore.Uri(), uri);
     ASSERT_EQ(restore->a, 1);
     ASSERT_EQ(restore->b, "hello");
@@ -57,10 +57,10 @@ TEST(AssetTest, AsyncLoadTest)
 {
     static Core::Uri uri("asset://Engine/Test/Generated/Runtime/AssetTest.SaveLoadTest");
 
-    AssetRef<TestAsset> asset = MakeShared<TestAsset>(uri, 1, "hello");
+    AssetPtr<TestAsset> asset = MakeShared<TestAsset>(uri, 1, "hello");
     AssetManager::Get().Save(asset);
 
-    AssetManager::Get().AsyncLoad<TestAsset>(uri, [&](AssetRef<TestAsset> restore) -> void {
+    AssetManager::Get().AsyncLoad<TestAsset>(uri, [&](AssetPtr<TestAsset> restore) -> void {
         ASSERT_EQ(restore.Uri(), uri);
         ASSERT_EQ(restore->a, 1);
         ASSERT_EQ(restore->b, "hello");
diff --git a/Sample/Base/Application.h b/Sample/Base/Application.h
index 0298d9f74..fe72e97fe 100644
--- a/Sample/Base/Application.h
+++ b/Sample/Base/Application.h
@@ -67,7 +67,7 @@ class Application {
     UVec2 windowExtent;
     RHI::RHIType rhiType;
     RHI::Instance* instance;
-    UniqueRef<Camera> camera;
+    UniquePtr<Camera> camera;
     FVec2 mousePos;
     std::array<bool, static_cast<size_t>(MouseButton::max)> mouseButtonsStatus;
     std::chrono::time_point<std::chrono::high_resolution_clock> lastTime;
diff --git a/Sample/RHI-ParallelCompute/ParallelCompute.cpp b/Sample/RHI-ParallelCompute/ParallelCompute.cpp
index fcc99315a..be060f611 100644
--- a/Sample/RHI-ParallelCompute/ParallelCompute.cpp
+++ b/Sample/RHI-ParallelCompute/ParallelCompute.cpp
@@ -71,7 +71,7 @@ class ParallelCompute final : public Application {
             .SetUsages(BufferUsageBits::mapWrite | BufferUsageBits::copySrc)
             .SetInitialState(BufferState::staging);
 
-        const UniqueRef<Buffer> stagingBuf = device->CreateBuffer(bufInfo);
+        const UniquePtr<Buffer> stagingBuf = device->CreateBuffer(bufInfo);
         if (stagingBuf != nullptr) {
             auto* mapPointer = stagingBuf->Map(MapMode::write, 0, bufInfo.size);
             memcpy(mapPointer, data.data(), bufInfo.size);
@@ -91,10 +91,10 @@ class ParallelCompute final : public Application {
             .SetExtendStorage(sizeof(PackedVec));
         inputBufferView = inputBuffer->CreateBufferView(inputBufViewInfo);
 
-        const UniqueRef<CommandBuffer> copyCmd = device->CreateCommandBuffer();
-        const UniqueRef<CommandRecorder> recorder = copyCmd->Begin();
+        const UniquePtr<CommandBuffer> copyCmd = device->CreateCommandBuffer();
+        const UniquePtr<CommandRecorder> recorder = copyCmd->Begin();
         {
-            const UniqueRef<CopyPassCommandRecorder> copyRecorder = recorder->BeginCopyPass();
+            const UniquePtr<CopyPassCommandRecorder> copyRecorder = recorder->BeginCopyPass();
             copyRecorder->ResourceBarrier(Barrier::Transition(inputBuffer.Get(), BufferState::undefined, BufferState::copyDst));
             copyRecorder->CopyBufferToBuffer(
                 stagingBuf.Get(),
@@ -105,7 +105,7 @@ class ParallelCompute final : public Application {
         }
         recorder->End();
 
-        const UniqueRef<Fence> mFence = device->CreateFence(false);
+        const UniquePtr<Fence> mFence = device->CreateFence(false);
         QueueSubmitInfo submitInfo {};
         submitInfo.signalFence = mFence.Get();
         queue->Submit(copyCmd.Get(), submitInfo);
@@ -168,17 +168,17 @@ class ParallelCompute final : public Application {
 
     void BuildCmdBufferAndSubmit()
     {
-        UniqueRef<CommandRecorder> recorder = commandBuffer->Begin();
+        UniquePtr<CommandRecorder> recorder = commandBuffer->Begin();
 
         // do compute work
-        UniqueRef<ComputePassCommandRecorder> computeRecorder = recorder->BeginComputePass();
+        UniquePtr<ComputePassCommandRecorder> computeRecorder = recorder->BeginComputePass();
         computeRecorder->SetPipeline(pipeline.Get());
         computeRecorder->SetBindGroup(0, bindGroup.Get());
         computeRecorder->Dispatch(1, 1, 1);
         computeRecorder->EndPass();
 
         // read back to host buffer
-        UniqueRef<CopyPassCommandRecorder> copyRecorder = recorder->BeginCopyPass();
+        UniquePtr<CopyPassCommandRecorder> copyRecorder = recorder->BeginCopyPass();
         copyRecorder->ResourceBarrier(Barrier::Transition(outputBuffer.Get(), BufferState::rwStorage, BufferState::copySrc));
         copyRecorder->CopyBufferToBuffer(
             outputBuffer.Get(),
@@ -202,24 +202,24 @@ class ParallelCompute final : public Application {
     const int dataNum = 32;
 
     Gpu* gpu = nullptr;
-    UniqueRef<Device> device;
+    UniquePtr<Device> device;
     Queue* queue = nullptr;
-    UniqueRef<Buffer> inputBuffer;
-    UniqueRef<BufferView> inputBufferView;
-    UniqueRef<Buffer> outputBuffer;
-    UniqueRef<BufferView> outputBufferView;
-    UniqueRef<Buffer> readbackBuffer;
-    UniqueRef<BindGroupLayout> bindGroupLayout;
-    UniqueRef<BindGroup> bindGroup;
-    UniqueRef<Sampler> sampler;
-    UniqueRef<CommandBuffer> cmdBuffer;
-    UniqueRef<PipelineLayout> pipelineLayout;
-    UniqueRef<ComputePipeline> pipeline;
-    UniqueRef<ShaderModule> computeShader;
-    UniqueRef<Fence> fence;
+    UniquePtr<Buffer> inputBuffer;
+    UniquePtr<BufferView> inputBufferView;
+    UniquePtr<Buffer> outputBuffer;
+    UniquePtr<BufferView> outputBufferView;
+    UniquePtr<Buffer> readbackBuffer;
+    UniquePtr<BindGroupLayout> bindGroupLayout;
+    UniquePtr<BindGroup> bindGroup;
+    UniquePtr<Sampler> sampler;
+    UniquePtr<CommandBuffer> cmdBuffer;
+    UniquePtr<PipelineLayout> pipelineLayout;
+    UniquePtr<ComputePipeline> pipeline;
+    UniquePtr<ShaderModule> computeShader;
+    UniquePtr<Fence> fence;
     ShaderCompileOutput csOutPut;
-    UniqueRef<ShaderModule> csShaderModule;
-    UniqueRef<CommandBuffer> commandBuffer;
+    UniquePtr<ShaderModule> csShaderModule;
+    UniquePtr<CommandBuffer> commandBuffer;
 };
 
 int main(int argc, char* argv[])
diff --git a/Sample/RHI-SSAO/GLTFParser.cpp b/Sample/RHI-SSAO/GLTFParser.cpp
index 9fa15ceef..047d5bf5a 100644
--- a/Sample/RHI-SSAO/GLTFParser.cpp
+++ b/Sample/RHI-SSAO/GLTFParser.cpp
@@ -40,8 +40,8 @@ void Model::LoadFromFile(const std::string& path)
 
     LoadMaterials(scene);
 
-    SharedRef<Node> parentForRoot = nullptr;
-    rootNode = SharedRef<Node>(new Node(parentForRoot));
+    SharedPtr<Node> parentForRoot = nullptr;
+    rootNode = SharedPtr<Node>(new Node(parentForRoot));
     for (unsigned int i = 0; i < scene->mRootNode->mNumChildren; i++) {
         LoadNode(scene, scene->mRootNode->mChildren[i], rootNode);
     }
@@ -54,7 +54,7 @@ void Model::LoadMaterials(const aiScene* scene)
     for (unsigned int i = 0; i < scene->mNumMaterials; i++) {
         const auto* material = scene->mMaterials[i];
 
-        SharedRef mMaterial = new MaterialData();
+        SharedPtr mMaterial = new MaterialData();
         mMaterial->baseColorTexture = LoadMaterialTexture(scene, material, aiTextureType_DIFFUSE, fromEmbedded);
         mMaterial->normalTexture = LoadMaterialTexture(scene, material, aiTextureType_NORMALS, fromEmbedded);
 
@@ -62,7 +62,7 @@ void Model::LoadMaterials(const aiScene* scene)
     }
 }
 
-UniqueRef<TextureData> Model::LoadMaterialTexture(const aiScene* scene, const aiMaterial* mat, aiTextureType type, bool fromEmbedded) const
+UniquePtr<TextureData> Model::LoadMaterialTexture(const aiScene* scene, const aiMaterial* mat, aiTextureType type, bool fromEmbedded) const
 {
     if (mat->GetTextureCount(type) == 0) {
         return nullptr;
@@ -84,7 +84,7 @@ UniqueRef<TextureData> Model::LoadMaterialTexture(const aiScene* scene, const ai
         data = stbi_load(filePath.c_str(), &width, &height, &comp,0);
     }
 
-    UniqueRef mTexData = new TextureData();
+    UniquePtr mTexData = new TextureData();
 
     // Most device don`t support RGB only on Vulkan, so convert if necessary
     if (comp == 3) {
@@ -111,9 +111,9 @@ UniqueRef<TextureData> Model::LoadMaterialTexture(const aiScene* scene, const ai
     return mTexData;
 }
 
-void Model::LoadNode(const aiScene* scene, aiNode* node, SharedRef<Node>& parent)
+void Model::LoadNode(const aiScene* scene, aiNode* node, SharedPtr<Node>& parent)
 {
-    SharedRef mNode = new Node(parent);
+    SharedPtr mNode = new Node(parent);
 
     // the layout of matrix in assimp math lib is row major, which is equal to expolsion math lib
     memcpy(mNode->matrix.data, &node->mTransformation.a1, sizeof(Common::FMat4x4));
@@ -184,7 +184,7 @@ void Model::LoadNode(const aiScene* scene, aiNode* node, SharedRef<Node>& parent
             }
         }
 
-        UniqueRef<Mesh> mMesh = new Mesh(indexStart, indexCount, vertexStart, vertexCount, materialDatas[mesh->mMaterialIndex]);
+        UniquePtr<Mesh> mMesh = new Mesh(indexStart, indexCount, vertexStart, vertexCount, materialDatas[mesh->mMaterialIndex]);
 
         // cache meshes in model instead of node, for the convenience of reading them
         meshes.emplace_back(std::move(mMesh));
diff --git a/Sample/RHI-SSAO/GLTFParser.h b/Sample/RHI-SSAO/GLTFParser.h
index 040532b64..26b74e37f 100644
--- a/Sample/RHI-SSAO/GLTFParser.h
+++ b/Sample/RHI-SSAO/GLTFParser.h
@@ -25,8 +25,8 @@ struct TextureData {
 
 struct MaterialData
 {
-    Common::UniqueRef<TextureData> baseColorTexture = nullptr;
-    Common::UniqueRef<TextureData> normalTexture = nullptr;
+    Common::UniquePtr<TextureData> baseColorTexture = nullptr;
+    Common::UniquePtr<TextureData> normalTexture = nullptr;
 };
 
 struct Vertex {
@@ -45,9 +45,9 @@ struct Mesh {
     uint32_t firstVertex;
     uint32_t vertexCount;
 
-    Common::SharedRef<MaterialData> materialData;
+    Common::SharedPtr<MaterialData> materialData;
 
-    Mesh(uint32_t firstIndex, uint32_t indexCount, uint32_t firstVertex, uint32_t vertexCount, Common::SharedRef<MaterialData>& material)
+    Mesh(uint32_t firstIndex, uint32_t indexCount, uint32_t firstVertex, uint32_t vertexCount, Common::SharedPtr<MaterialData>& material)
         : firstIndex(firstIndex)
         , indexCount(indexCount)
         , firstVertex(firstVertex)
@@ -60,14 +60,14 @@ struct Mesh {
 };
 
 struct Node {
-    explicit Node(Common::SharedRef<Node>& p)
-        : parent(Common::WeakRef<Node>(p))
+    explicit Node(Common::SharedPtr<Node>& p)
+        : parent(Common::WeakPtr<Node>(p))
         , matrix(Common::FMat4x4Consts::identity)
     {
     }
 
-    Common::WeakRef<Node> parent;
-    std::vector<Common::SharedRef<Node>> children;
+    Common::WeakPtr<Node> parent;
+    std::vector<Common::SharedPtr<Node>> children;
 
     Common::FMat4x4 matrix;
 
@@ -82,11 +82,11 @@ class Model {
     ~Model() = default;
 
     void LoadFromFile(const std::string& path);
-    void LoadNode(const aiScene* scene, aiNode* node, Common::SharedRef<Node>& parent);
+    void LoadNode(const aiScene* scene, aiNode* node, Common::SharedPtr<Node>& parent);
     void LoadMaterials(const aiScene* scene);
 
 private:
-    Common::UniqueRef<TextureData> LoadMaterialTexture(const aiScene* scene, const aiMaterial* mat, aiTextureType type, bool fromEmbedded) const;
+    Common::UniquePtr<TextureData> LoadMaterialTexture(const aiScene* scene, const aiMaterial* mat, aiTextureType type, bool fromEmbedded) const;
 
     void CreateEmptyTexture() const
     {
@@ -97,13 +97,13 @@ class Model {
     }
 
 public:
-    Common::SharedRef<Node> rootNode;
-    std::vector<Common::SharedRef<MaterialData>> materialDatas;
+    Common::SharedPtr<Node> rootNode;
+    std::vector<Common::SharedPtr<MaterialData>> materialDatas;
     std::vector<uint32_t> rawIndBuffer;
     std::vector<Vertex> rawVertBuffer;
-    std::vector<Common::UniqueRef<Mesh>> meshes;
+    std::vector<Common::UniquePtr<Mesh>> meshes;
     std::string directory;
 
 private:
-    Common::UniqueRef<TextureData> emptyTexture = nullptr;
+    Common::UniquePtr<TextureData> emptyTexture = nullptr;
 };
diff --git a/Sample/RHI-SSAO/SSAOApplication.cpp b/Sample/RHI-SSAO/SSAOApplication.cpp
index ce7702e7d..32241a98a 100644
--- a/Sample/RHI-SSAO/SSAOApplication.cpp
+++ b/Sample/RHI-SSAO/SSAOApplication.cpp
@@ -52,14 +52,14 @@ class SSAOApplication final : public Application {
         const auto backTextureIndex = swapChain->AcquireBackTexture(backBufferReadySemaphores[nextFrameIndex].Get());
         inflightFences[nextFrameIndex]->Reset();
 
-        const UniqueRef<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
+        const UniquePtr<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
         {
             commandRecorder->ResourceBarrier(Barrier::Transition(gBufferPos.texture.Get(), TextureState::shaderReadOnly, TextureState::renderTarget));
             commandRecorder->ResourceBarrier(Barrier::Transition(gBufferNormal.texture.Get(), TextureState::shaderReadOnly, TextureState::renderTarget));
             commandRecorder->ResourceBarrier(Barrier::Transition(gBufferAlbedo.texture.Get(), TextureState::shaderReadOnly, TextureState::renderTarget));
             commandRecorder->ResourceBarrier(Barrier::Transition(gBufferDepth.texture.Get(), TextureState::depthStencilReadonly, TextureState::depthStencilWrite));
 
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(RHI::ColorAttachment(gBufferPos.rtv.Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black))
                     .AddColorAttachment(RHI::ColorAttachment(gBufferNormal.rtv.Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black))
@@ -91,7 +91,7 @@ class SSAOApplication final : public Application {
             // ssao
             commandRecorder->ResourceBarrier(Barrier::Transition(ssaoOutput.texture.Get(), TextureState::shaderReadOnly, TextureState::renderTarget));
 
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(RHI::ColorAttachment(ssaoOutput.rtv.Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black)));
             {
@@ -112,7 +112,7 @@ class SSAOApplication final : public Application {
             // ssaoBlur
             commandRecorder->ResourceBarrier(Barrier::Transition(ssaoBlurOutput.texture.Get(), TextureState::shaderReadOnly, TextureState::renderTarget));
 
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(RHI::ColorAttachment(ssaoBlurOutput.rtv.Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black)));
             {
@@ -132,7 +132,7 @@ class SSAOApplication final : public Application {
         {
             // composition
             commandRecorder->ResourceBarrier(Barrier::Transition(swapChainTextures[backTextureIndex], TextureState::present, TextureState::renderTarget));
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(RHI::ColorAttachment(swapChainTextureViews[backTextureIndex].Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black)));
             {
@@ -163,7 +163,7 @@ class SSAOApplication final : public Application {
 
     void OnDestroy() override
     {
-        const UniqueRef<Fence> fence = device->CreateFence(false);
+        const UniquePtr<Fence> fence = device->CreateFence(false);
         graphicsQueue->Flush(fence.Get());
         fence->Wait();
     }
@@ -175,38 +175,38 @@ class SSAOApplication final : public Application {
 
     PixelFormat swapChainFormat = PixelFormat::max;
     Gpu* gpu = nullptr;
-    UniqueRef<Device> device = nullptr;
+    UniquePtr<Device> device = nullptr;
     Queue* graphicsQueue = nullptr;
-    UniqueRef<Surface> surface = nullptr;
-    UniqueRef<SwapChain> swapChain = nullptr;
-    UniqueRef<Buffer> vertexBuffer = nullptr;
-    UniqueRef<BufferView> vertexBufferView = nullptr;
-    UniqueRef<Buffer> indexBuffer = nullptr;
-    UniqueRef<BufferView> indexBufferView = nullptr;
+    UniquePtr<Surface> surface = nullptr;
+    UniquePtr<SwapChain> swapChain = nullptr;
+    UniquePtr<Buffer> vertexBuffer = nullptr;
+    UniquePtr<BufferView> vertexBufferView = nullptr;
+    UniquePtr<Buffer> indexBuffer = nullptr;
+    UniquePtr<BufferView> indexBufferView = nullptr;
     std::array<Texture*, backBufferCount> swapChainTextures {};
-    std::array<UniqueRef<TextureView>, backBufferCount> swapChainTextureViews {};
+    std::array<UniquePtr<TextureView>, backBufferCount> swapChainTextureViews {};
 
-    UniqueRef<Buffer> quadVertexBuffer = nullptr;
-    UniqueRef<BufferView> quadVertexBufferView = nullptr;
-    UniqueRef<Buffer> quadIndexBuffer = nullptr;
-    UniqueRef<BufferView> quadIndexBufferView = nullptr;
+    UniquePtr<Buffer> quadVertexBuffer = nullptr;
+    UniquePtr<BufferView> quadVertexBufferView = nullptr;
+    UniquePtr<Buffer> quadIndexBuffer = nullptr;
+    UniquePtr<BufferView> quadIndexBufferView = nullptr;
 
-    std::array<UniqueRef<CommandBuffer>, backBufferCount> commandBuffers {};
-    std::array<UniqueRef<Semaphore>, backBufferCount> backBufferReadySemaphores {};
-    std::array<UniqueRef<Semaphore>, backBufferCount> renderFinishedSemaphores {};
-    std::array<UniqueRef<Fence>, backBufferCount> inflightFences {};
+    std::array<UniquePtr<CommandBuffer>, backBufferCount> commandBuffers {};
+    std::array<UniquePtr<Semaphore>, backBufferCount> backBufferReadySemaphores {};
+    std::array<UniquePtr<Semaphore>, backBufferCount> renderFinishedSemaphores {};
+    std::array<UniquePtr<Fence>, backBufferCount> inflightFences {};
     uint8_t nextFrameIndex = 0;
 
-    UniqueRef<Sampler> sampler = nullptr;
-    UniqueRef<Sampler> noiseSampler = nullptr;
+    UniquePtr<Sampler> sampler = nullptr;
+    UniquePtr<Sampler> noiseSampler = nullptr;
 
     struct Renderable {
         uint32_t indexCount;
         uint32_t firstIndex;
 
-        UniqueRef<BindGroup> bindGroup;
-        UniqueRef<Texture> diffuseColorMap;
-        UniqueRef<TextureView> diffuseColorMapView;
+        UniquePtr<BindGroup> bindGroup;
+        UniquePtr<Texture> diffuseColorMap;
+        UniquePtr<TextureView> diffuseColorMapView;
 
         Renderable(Instance& instance, Device& device, BindGroupLayout& bindGroupLayout, Render::ShaderReflectionData& gBufferPsReflectionData, Sampler& sampler, const Mesh& mesh) {
             indexCount = mesh.indexCount;
@@ -242,7 +242,7 @@ class SSAOApplication final : public Application {
                 .SetUsages(BufferUsageBits::uniform | BufferUsageBits::mapWrite | BufferUsageBits::copySrc)
                 .SetInitialState(BufferState::staging);
 
-            const UniqueRef<Buffer> pixelBuffer = device.CreateBuffer(bufferCreateInfo);
+            const UniquePtr<Buffer> pixelBuffer = device.CreateBuffer(bufferCreateInfo);
             if (pixelBuffer != nullptr) {
                 auto* data = pixelBuffer->Map(MapMode::write, 0, bufferCreateInfo.size);
                 for (auto i = 0; i < texData->height; i++) {
@@ -254,10 +254,10 @@ class SSAOApplication final : public Application {
                 pixelBuffer->UnMap();
             }
 
-            const UniqueRef<CommandBuffer> texCommandBuffer = device.CreateCommandBuffer();
-            const UniqueRef<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
+            const UniquePtr<CommandBuffer> texCommandBuffer = device.CreateCommandBuffer();
+            const UniquePtr<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
             {
-                const UniqueRef<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
+                const UniquePtr<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
                 {
                     copyRecorder->ResourceBarrier(Barrier::Transition(diffuseColorMap.Get(), TextureState::undefined, TextureState::copyDst));
                     copyRecorder->CopyBufferToTexture(
@@ -270,7 +270,7 @@ class SSAOApplication final : public Application {
             }
             commandRecorder->End();
 
-            const UniqueRef<Fence> fence = device.CreateFence(false);
+            const UniquePtr<Fence> fence = device.CreateFence(false);
             QueueSubmitInfo submitInfo {};
             submitInfo.signalFence = fence.Get();
             device.GetQueue(QueueType::graphics, 0)->Submit(texCommandBuffer.Get(), submitInfo);
@@ -284,12 +284,12 @@ class SSAOApplication final : public Application {
         }
     };
 
-    UniqueRef<Model> model = nullptr;
-    std::vector<UniqueRef<Renderable>> renderables;
+    UniquePtr<Model> model = nullptr;
+    std::vector<UniquePtr<Renderable>> renderables;
 
     struct UBuffer {
-        UniqueRef<Buffer> buf;
-        UniqueRef<BufferView> bufView;
+        UniquePtr<Buffer> buf;
+        UniquePtr<BufferView> bufView;
     };
 
     struct UniformBuffers {
@@ -315,19 +315,19 @@ class SSAOApplication final : public Application {
     } ubossaoParams;
 
     struct Noise {
-        UniqueRef<Texture> tex;
-        UniqueRef<TextureView> view;
+        UniquePtr<Texture> tex;
+        UniquePtr<TextureView> view;
     } noise;
 
     struct ShaderObjects {
-        UniqueRef<ShaderModule> gBufferVs;
-        UniqueRef<ShaderModule> gBufferPs;
-        UniqueRef<ShaderModule> ssaoVs;
-        UniqueRef<ShaderModule> ssaoPs;
-        UniqueRef<ShaderModule> ssaoBlurVs;
-        UniqueRef<ShaderModule> ssaoBlurPs;
-        UniqueRef<ShaderModule> compositionVs;
-        UniqueRef<ShaderModule> compositionPs;
+        UniquePtr<ShaderModule> gBufferVs;
+        UniquePtr<ShaderModule> gBufferPs;
+        UniquePtr<ShaderModule> ssaoVs;
+        UniquePtr<ShaderModule> ssaoPs;
+        UniquePtr<ShaderModule> ssaoBlurVs;
+        UniquePtr<ShaderModule> ssaoBlurPs;
+        UniquePtr<ShaderModule> compositionVs;
+        UniquePtr<ShaderModule> compositionPs;
         ShaderCompileOutput gBufferVsCompileOutput;
         ShaderCompileOutput gBufferPsCompileOutput;
         ShaderCompileOutput ssaoVsCompileOutput;
@@ -339,47 +339,47 @@ class SSAOApplication final : public Application {
     } shaderObjects;
 
     struct Pipelines {
-        UniqueRef<RasterPipeline> gBuffer;
-        UniqueRef<RasterPipeline> ssao;
-        UniqueRef<RasterPipeline> ssaoBlur;
-        UniqueRef<RasterPipeline> composition;
+        UniquePtr<RasterPipeline> gBuffer;
+        UniquePtr<RasterPipeline> ssao;
+        UniquePtr<RasterPipeline> ssaoBlur;
+        UniquePtr<RasterPipeline> composition;
     } pipelines;
 
     struct PipelineLayouts {
-        UniqueRef<PipelineLayout> gBuffer;
-        UniqueRef<PipelineLayout> ssao;
-        UniqueRef<PipelineLayout> ssaoBlur;
-        UniqueRef<PipelineLayout> composition;
+        UniquePtr<PipelineLayout> gBuffer;
+        UniquePtr<PipelineLayout> ssao;
+        UniquePtr<PipelineLayout> ssaoBlur;
+        UniquePtr<PipelineLayout> composition;
     } pipelineLayouts;
 
-    UniqueRef<BindGroupLayout> renderableLayout;
+    UniquePtr<BindGroupLayout> renderableLayout;
 
     struct BindGroupLayouts {
-        UniqueRef<BindGroupLayout> gBuffer;
-        UniqueRef<BindGroupLayout> ssao;
-        UniqueRef<BindGroupLayout> ssaoBlur;
-        UniqueRef<BindGroupLayout> composition;
+        UniquePtr<BindGroupLayout> gBuffer;
+        UniquePtr<BindGroupLayout> ssao;
+        UniquePtr<BindGroupLayout> ssaoBlur;
+        UniquePtr<BindGroupLayout> composition;
     } bindGroupLayouts;
 
     struct BindGroups {
-        UniqueRef<BindGroup> scene;
-        UniqueRef<BindGroup> ssao;
-        UniqueRef<BindGroup> ssaoBlur;
-        UniqueRef<BindGroup> composition;
+        UniquePtr<BindGroup> scene;
+        UniquePtr<BindGroup> ssao;
+        UniquePtr<BindGroup> ssaoBlur;
+        UniquePtr<BindGroup> composition;
     } bindGroups;
 
     struct ColorAttachment {
-        UniqueRef<Texture> texture;
-        UniqueRef<TextureView> rtv;
-        UniqueRef<TextureView> srv;
+        UniquePtr<Texture> texture;
+        UniquePtr<TextureView> rtv;
+        UniquePtr<TextureView> srv;
     };
 
     ColorAttachment gBufferPos;
     ColorAttachment gBufferNormal;
     ColorAttachment gBufferAlbedo;
     struct {
-        UniqueRef<Texture> texture;
-        UniqueRef<TextureView> view;
+        UniquePtr<Texture> texture;
+        UniquePtr<TextureView> view;
     } gBufferDepth;
 
     ColorAttachment ssaoOutput;
@@ -757,7 +757,7 @@ class SSAOApplication final : public Application {
             .SetUsages(BufferUsageBits::mapWrite | BufferUsageBits::copySrc)
             .SetInitialState(BufferState::staging);
 
-        const UniqueRef<Buffer> pixelBuffer = device->CreateBuffer(bufferCreateInfo);
+        const UniquePtr<Buffer> pixelBuffer = device->CreateBuffer(bufferCreateInfo);
         if (pixelBuffer != nullptr) {
             auto* data = pixelBuffer->Map(MapMode::write, 0, bufferCreateInfo.size);
             memcpy(data, ssaoNoise.data(), bufferCreateInfo.size);
@@ -789,11 +789,11 @@ class SSAOApplication final : public Application {
                 .SetAddressModeU(AddressMode::repeat)
                 .SetAddressModeV(AddressMode::repeat));
 
-        const UniqueRef<CommandBuffer> texCommandBuffer = device->CreateCommandBuffer();
+        const UniquePtr<CommandBuffer> texCommandBuffer = device->CreateCommandBuffer();
 
-        const UniqueRef<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
+        const UniquePtr<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
         {
-            const UniqueRef<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
+            const UniquePtr<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
             {
                 copyRecorder->ResourceBarrier(Barrier::Transition(noise.tex.Get(), TextureState::undefined, TextureState::copyDst));
                 copyRecorder->CopyBufferToTexture(
@@ -806,7 +806,7 @@ class SSAOApplication final : public Application {
         }
         commandRecorder->End();
 
-        const UniqueRef<Fence> fence = device->CreateFence(false);
+        const UniquePtr<Fence> fence = device->CreateFence(false);
         QueueSubmitInfo submitInfo {};
         submitInfo.signalFence = fence.Get();
         graphicsQueue->Submit(texCommandBuffer.Get(), submitInfo);
@@ -866,7 +866,7 @@ class SSAOApplication final : public Application {
                 .SetType(TextureViewType::textureBinding));
     }
 
-    void CompileShaderAndCreateShaderModule(UniqueRef<ShaderModule>& outShaderModule, ShaderCompileOutput& outCompileOutput, const std::string& fileName, const std::string& entryPoint, ShaderStageBits shaderStage) const
+    void CompileShaderAndCreateShaderModule(UniquePtr<ShaderModule>& outShaderModule, ShaderCompileOutput& outCompileOutput, const std::string& fileName, const std::string& entryPoint, ShaderStageBits shaderStage) const
     {
         const std::vector<std::string> includePath { "../Test/Sample/RHI-SSAO/Shader"};
         outCompileOutput = CompileShader(fileName, entryPoint, shaderStage, includePath);
diff --git a/Sample/RHI-TexSampling/TexSampling.cpp b/Sample/RHI-TexSampling/TexSampling.cpp
index b84e34724..bcf13dbd9 100644
--- a/Sample/RHI-TexSampling/TexSampling.cpp
+++ b/Sample/RHI-TexSampling/TexSampling.cpp
@@ -42,10 +42,10 @@ class TexSamplingApplication final : public Application {
         const auto backTextureIndex = swapChain->AcquireBackTexture(backBufferReadySemaphores[nextFrameIndex].Get());
         inflightFences[nextFrameIndex]->Reset();
 
-        const UniqueRef<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
+        const UniquePtr<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
         {
             commandRecorder->ResourceBarrier(Barrier::Transition(swapChainTextures[backTextureIndex], TextureState::present, TextureState::renderTarget));
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(ColorAttachment(swapChainTextureViews[backTextureIndex].Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black)));
             {
@@ -75,7 +75,7 @@ class TexSamplingApplication final : public Application {
 
     void OnDestroy() override
     {
-        const UniqueRef<Fence> fence = device->CreateFence(false);
+        const UniquePtr<Fence> fence = device->CreateFence(false);
         graphicsQueue->Flush(fence.Get());
         fence->Wait();
     }
@@ -249,9 +249,9 @@ class TexSamplingApplication final : public Application {
         sampler = device->CreateSampler(SamplerCreateInfo());
 
         texCommandBuffer = device->CreateCommandBuffer();
-        const UniqueRef<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
+        const UniquePtr<CommandRecorder> commandRecorder = texCommandBuffer->Begin();
         {
-            const UniqueRef<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
+            const UniquePtr<CopyPassCommandRecorder> copyRecorder = commandRecorder->BeginCopyPass();
             {
                 copyRecorder->ResourceBarrier(Barrier::Transition(sampleTexture.Get(), TextureState::undefined, TextureState::copyDst));
                 copyRecorder->CopyBufferToTexture(
@@ -264,7 +264,7 @@ class TexSamplingApplication final : public Application {
         }
         commandRecorder->End();
 
-        const UniqueRef<Fence> fence = device->CreateFence(false);
+        const UniquePtr<Fence> fence = device->CreateFence(false);
         QueueSubmitInfo submitInfo {};
         submitInfo.signalFence = fence.Get();
         graphicsQueue->Submit(texCommandBuffer.Get(), submitInfo);
@@ -379,35 +379,35 @@ class TexSamplingApplication final : public Application {
 
     PixelFormat swapChainFormat = PixelFormat::max;
     Gpu* gpu = nullptr;
-    UniqueRef<Device> device;
+    UniquePtr<Device> device;
     Queue* graphicsQueue = nullptr;
-    UniqueRef<Surface> surface;
-    UniqueRef<SwapChain> swapChain;
-    UniqueRef<Buffer> vertexBuffer;
-    UniqueRef<BufferView> vertexBufferView;
-    UniqueRef<Buffer> indexBuffer;
-    UniqueRef<BufferView> indexBufferView;
-    UniqueRef<BindGroupLayout> bindGroupLayout;
-    UniqueRef<BindGroup> bindGroup;
-    UniqueRef<Texture> sampleTexture;
-    UniqueRef<TextureView> sampleTextureView;
-    UniqueRef<Sampler> sampler;
-    UniqueRef<Buffer> uniformBuffer;
-    UniqueRef<BufferView> uniformBufferView;
-    UniqueRef<CommandBuffer> texCommandBuffer;
-    UniqueRef<Buffer> pixelBuffer;
+    UniquePtr<Surface> surface;
+    UniquePtr<SwapChain> swapChain;
+    UniquePtr<Buffer> vertexBuffer;
+    UniquePtr<BufferView> vertexBufferView;
+    UniquePtr<Buffer> indexBuffer;
+    UniquePtr<BufferView> indexBufferView;
+    UniquePtr<BindGroupLayout> bindGroupLayout;
+    UniquePtr<BindGroup> bindGroup;
+    UniquePtr<Texture> sampleTexture;
+    UniquePtr<TextureView> sampleTextureView;
+    UniquePtr<Sampler> sampler;
+    UniquePtr<Buffer> uniformBuffer;
+    UniquePtr<BufferView> uniformBufferView;
+    UniquePtr<CommandBuffer> texCommandBuffer;
+    UniquePtr<Buffer> pixelBuffer;
     std::array<Texture*, backBufferCount> swapChainTextures {};
-    std::array<UniqueRef<TextureView>, backBufferCount> swapChainTextureViews;
-    UniqueRef<PipelineLayout> pipelineLayout;
-    UniqueRef<RasterPipeline> pipeline;
-    UniqueRef<ShaderModule> vertexShader;
+    std::array<UniquePtr<TextureView>, backBufferCount> swapChainTextureViews;
+    UniquePtr<PipelineLayout> pipelineLayout;
+    UniquePtr<RasterPipeline> pipeline;
+    UniquePtr<ShaderModule> vertexShader;
     ShaderCompileOutput vsCompileOutput;
-    UniqueRef<ShaderModule> pixelShader;
+    UniquePtr<ShaderModule> pixelShader;
     ShaderCompileOutput psCompileOutput;
-    std::array<UniqueRef<CommandBuffer>, backBufferCount> commandBuffers;
-    std::array<UniqueRef<Semaphore>, backBufferCount> backBufferReadySemaphores;
-    std::array<UniqueRef<Semaphore>, backBufferCount> renderFinishedSemaphores;
-    std::array<UniqueRef<Fence>, backBufferCount> inflightFences;
+    std::array<UniquePtr<CommandBuffer>, backBufferCount> commandBuffers;
+    std::array<UniquePtr<Semaphore>, backBufferCount> backBufferReadySemaphores;
+    std::array<UniquePtr<Semaphore>, backBufferCount> renderFinishedSemaphores;
+    std::array<UniquePtr<Fence>, backBufferCount> inflightFences;
     uint8_t nextFrameIndex = 0;
 };
 
diff --git a/Sample/RHI-Triangle/Triangle.cpp b/Sample/RHI-Triangle/Triangle.cpp
index 005d36e2f..3385bbd4b 100644
--- a/Sample/RHI-Triangle/Triangle.cpp
+++ b/Sample/RHI-Triangle/Triangle.cpp
@@ -41,10 +41,10 @@ class TriangleApplication final : public Application {
         const auto backTextureIndex = swapChain->AcquireBackTexture(backBufferReadySemaphores[nextFrameIndex].Get());
         inflightFences[nextFrameIndex]->Reset();
 
-        const UniqueRef<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
+        const UniquePtr<CommandRecorder> commandRecorder = commandBuffers[nextFrameIndex]->Begin();
         {
             commandRecorder->ResourceBarrier(Barrier::Transition(swapChainTextures[backTextureIndex], TextureState::present, TextureState::renderTarget));
-            const UniqueRef<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
+            const UniquePtr<RasterPassCommandRecorder> rasterRecorder = commandRecorder->BeginRasterPass(
                 RasterPassBeginInfo()
                     .AddColorAttachment(ColorAttachment(swapChainTextureViews[backTextureIndex].Get(), LoadOp::clear, StoreOp::store, LinearColorConsts::black)));
             {
@@ -73,7 +73,7 @@ class TriangleApplication final : public Application {
 
     void OnDestroy() override
     {
-        const UniqueRef<Fence> fence = device->CreateFence(false);
+        const UniquePtr<Fence> fence = device->CreateFence(false);
         graphicsQueue->Flush(fence.Get());
         fence->Wait();
     }
@@ -213,24 +213,24 @@ class TriangleApplication final : public Application {
 
     PixelFormat swapChainFormat = PixelFormat::max;
     Gpu* gpu = nullptr;
-    UniqueRef<Device> device;
+    UniquePtr<Device> device;
     Queue* graphicsQueue = nullptr;
-    UniqueRef<Surface> surface;
-    UniqueRef<SwapChain> swapChain;
-    UniqueRef<Buffer> vertexBuffer;
-    UniqueRef<BufferView> vertexBufferView;
+    UniquePtr<Surface> surface;
+    UniquePtr<SwapChain> swapChain;
+    UniquePtr<Buffer> vertexBuffer;
+    UniquePtr<BufferView> vertexBufferView;
     std::array<Texture*, backBufferCount> swapChainTextures {};
-    std::array<UniqueRef<TextureView>, backBufferCount> swapChainTextureViews;
-    UniqueRef<PipelineLayout> pipelineLayout;
-    UniqueRef<RasterPipeline> pipeline;
-    UniqueRef<ShaderModule> vertexShader;
+    std::array<UniquePtr<TextureView>, backBufferCount> swapChainTextureViews;
+    UniquePtr<PipelineLayout> pipelineLayout;
+    UniquePtr<RasterPipeline> pipeline;
+    UniquePtr<ShaderModule> vertexShader;
     ShaderCompileOutput vsCompileOutput;
-    UniqueRef<ShaderModule> pixelShader;
+    UniquePtr<ShaderModule> pixelShader;
     ShaderCompileOutput psCompileOutput;
-    std::array<UniqueRef<CommandBuffer>, backBufferCount> commandBuffers;
-    std::array<UniqueRef<Semaphore>, backBufferCount> backBufferReadySemaphores;
-    std::array<UniqueRef<Semaphore>, backBufferCount> renderFinishedSemaphores;
-    std::array<UniqueRef<Fence>, backBufferCount> inflightFences;
+    std::array<UniquePtr<CommandBuffer>, backBufferCount> commandBuffers;
+    std::array<UniquePtr<Semaphore>, backBufferCount> backBufferReadySemaphores;
+    std::array<UniquePtr<Semaphore>, backBufferCount> renderFinishedSemaphores;
+    std::array<UniquePtr<Fence>, backBufferCount> inflightFences;
     uint8_t nextFrameIndex = 0;
 };
 
diff --git a/Sample/Rendering-Triangle/Triangle.cpp b/Sample/Rendering-Triangle/Triangle.cpp
index aefea9188..e970a73cc 100644
--- a/Sample/Rendering-Triangle/Triangle.cpp
+++ b/Sample/Rendering-Triangle/Triangle.cpp
@@ -6,6 +6,7 @@
 #include <RHI/RHI.h>
 #include <Render/ShaderCompiler.h>
 #include <Render/RenderGraph.h>
+#include <Render/RenderThread.h>
 
 using namespace Common;
 using namespace Render;
@@ -61,21 +62,22 @@ class TriangleApplication final : public Application {
     void CreateTriangleVertexBuffer();
     void CreateSyncObjects();
 
-    PixelFormat swapChainFormat = PixelFormat::max;
+    PixelFormat swapChainFormat;
     ShaderInstance triangleVS;
     ShaderInstance trianglePS;
-    UniqueRef<Device> device;
-    UniqueRef<Surface> surface;
-    UniqueRef<SwapChain> swapChain;
+    UniquePtr<Device> device;
+    UniquePtr<Surface> surface;
+    UniquePtr<SwapChain> swapChain;
     std::array<Texture*, backBufferCount> swapChainTextures {};
-    UniqueRef<Buffer> triangleVertexBuffer;
-    UniqueRef<Semaphore> imageReadySemaphore;
-    UniqueRef<Semaphore> renderFinishedSemaphore;
-    UniqueRef<Fence> frameFence;
+    UniquePtr<Buffer> triangleVertexBuffer;
+    UniquePtr<Semaphore> imageReadySemaphore;
+    UniquePtr<Semaphore> renderFinishedSemaphore;
+    UniquePtr<Fence> frameFence;
 };
 
 TriangleApplication::TriangleApplication(const std::string& inName)
     : Application(inName)
+    , swapChainFormat(PixelFormat::max)
 {
 }
 
@@ -83,6 +85,7 @@ TriangleApplication::~TriangleApplication() = default;
 
 void TriangleApplication::OnCreate()
 {
+    RenderWorkerThreads::Get().Start();
     CreateDevice();
     CompileAllShaders();
     CreateSwapChain();
@@ -97,17 +100,17 @@ void TriangleApplication::OnDrawFrame()
 
     auto* pso = PipelineCache::Get(*device).GetOrCreate(
         RasterPipelineStateDesc()
-                .SetVertexShader(triangleVS)
-                .SetPixelShader(trianglePS)
-                .SetVertexState(
-                    RVertexState()
-                        .AddVertexBufferLayout(
-                            RVertexBufferLayout(VertexStepMode::perVertex, sizeof(Vertex))
-                                .AddAttribute(RVertexAttribute(RVertexBinding("POSITION", 0), VertexFormat::float32X3, offsetof(Vertex, position)))
-                                .AddAttribute(RVertexAttribute(RVertexBinding("COLOR", 0), VertexFormat::float32X3, offsetof(Vertex, color)))))
-                .SetFragmentState(
-                    RFragmentState()
-                        .AddColorTarget(ColorTargetState(swapChainFormat, ColorWriteBits::all, false))));
+            .SetVertexShader(triangleVS)
+            .SetPixelShader(trianglePS)
+            .SetVertexState(
+                RVertexState()
+                    .AddVertexBufferLayout(
+                        RVertexBufferLayout(VertexStepMode::perVertex, sizeof(Vertex))
+                            .AddAttribute(RVertexAttribute(RVertexBinding("POSITION", 0), VertexFormat::float32X3, offsetof(Vertex, position)))
+                            .AddAttribute(RVertexAttribute(RVertexBinding("COLOR", 0), VertexFormat::float32X3, offsetof(Vertex, color)))))
+            .SetFragmentState(
+                RFragmentState()
+                    .AddColorTarget(ColorTargetState(swapChainFormat, ColorWriteBits::all, false))));
 
     RGBuilder builder(*device);
     auto* backTexture = builder.ImportTexture(swapChainTextures[backTextureIndex], TextureState::present);
@@ -118,15 +121,18 @@ void TriangleApplication::OnDrawFrame()
     builder.AddRasterPass(
         "BasePass",
         RGRasterPassDesc()
-            .AddColorAttachment(RGColorAttachment(backTextureView, LoadOp::load, StoreOp::store)),
+            .AddColorAttachment(RGColorAttachment(backTextureView, LoadOp::clear, StoreOp::store)),
         {},
-        [pso, vertexBufferView, backTexture, viewportWidth = GetWindowWidth(), viewportHeight = GetWindowHeight()](const RGBuilder& rg, RasterPassCommandRecorder& recorder) -> void {
+        [pso, vertexBufferView, viewportWidth = GetWindowWidth(), viewportHeight = GetWindowHeight()](const RGBuilder& rg, RasterPassCommandRecorder& recorder) -> void {
             recorder.SetPipeline(pso->GetRHI());
             recorder.SetScissor(0, 0, viewportWidth, viewportHeight);
             recorder.SetViewport(0, 0, static_cast<float>(viewportWidth), static_cast<float>(viewportHeight), 0, 1);
             recorder.SetVertexBuffer(0, rg.GetRHI(vertexBufferView));
             recorder.SetPrimitiveTopology(PrimitiveTopology::triangleList);
             recorder.Draw(3, 1, 0, 0);
+        },
+        {},
+        [backTexture](const RGBuilder& rg, CommandRecorder& recorder) -> void {
             recorder.ResourceBarrier(Barrier::Transition(rg.GetRHI(backTexture), TextureState::renderTarget, TextureState::present));
         });
 
@@ -137,17 +143,21 @@ void TriangleApplication::OnDrawFrame()
     builder.Execute(executeInfo);
     swapChain->Present(renderFinishedSemaphore.Get());
     frameFence->Wait();
+
+    BufferPool::Get(*device).Tick();
+    TexturePool::Get(*device).Tick();
 }
 
 void TriangleApplication::OnDestroy()
 {
-    const UniqueRef<Fence> fence = device->CreateFence(false);
+    const UniquePtr<Fence> fence = device->CreateFence(false);
     device->GetQueue(QueueType::graphics, 0)->Flush(fence.Get());
     fence->Wait();
 
     ResourceViewCache::Get(*device).Invalidate();
     PipelineCache::Get(*device).Invalidate();
     GlobalShaderRegistry::Get().InvalidateAll();
+    RenderWorkerThreads::Get().Stop();
 }
 
 void TriangleApplication::CreateDevice()
@@ -208,9 +218,9 @@ void TriangleApplication::CreateSwapChain()
 void TriangleApplication::CreateTriangleVertexBuffer()
 {
     const std::vector<Vertex> vertices = {
-        {{-.5f, -.5f, 0.f}, {1.f, 0.f, 0.f}},
-        {{.5f, -.5f, 0.f}, {0.f, 1.f, 0.f}},
-        {{0.f, .5f, 0.f}, {0.f, 0.f, 1.f}},
+        { { -.5f, -.5f, 0.f }, { 1.f, 0.f, 0.f } },
+        { { .5f, -.5f, 0.f }, { 0.f, 1.f, 0.f } },
+        { { 0.f, .5f, 0.f }, { 0.f, 0.f, 1.f } },
     };
 
     const BufferCreateInfo bufferCreateInfo = BufferCreateInfo()