diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4bad430..1cd0b2a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,16 +1,15 @@
 cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 
-project(UECS VERSION 0.14.4)
+project(UECS VERSION 0.15.0)
 message(STATUS "[Project] ${PROJECT_NAME}")
 
 include(cmake/InitUCMake.cmake)
-Ubpa_InitUCMake()
+Ubpa_InitUCMake(VERSION 0.6.4)
 
 Ubpa_InitProject()
 
-Ubpa_AddDep(UContainer 0.0.9)
-Ubpa_AddDep(UTemplate  0.4.9)
-Ubpa_AddDep(UGraphviz  0.1.6)
+Ubpa_AddDep(UTemplate  0.6.0)
+Ubpa_AddDep(UGraphviz  0.2.0)
 
 Ubpa_AddSubDirsRec(include)
 Ubpa_AddSubDirsRec(src)
diff --git a/cmake/InitUCMake.cmake b/cmake/InitUCMake.cmake
index 7cdb7da..61c2946 100644
--- a/cmake/InitUCMake.cmake
+++ b/cmake/InitUCMake.cmake
@@ -1,6 +1,22 @@
 macro(Ubpa_InitUCMake)
+  cmake_parse_arguments(
+    "ARG" # prefix
+    "" #<options> # TRUE / FALSE
+    "VERSION" # <one_value_keywords>
+    "" #<multi_value_keywords> # list
+    ${ARGN}
+  )
+  # 结果为 ARG_*
+  # - ARG_<option>
+  # - ARG_<one_value_keyword>
+  # - ARG_<multi_value_keyword>
+  
+  if("${ARG_VERSION}" STREQUAL "")
+    message(FATAL_ERROR "not provide argument <VERSION>")
+  endif()
+  
   include(FetchContent)
-  set(UCMake_VERSION 0.6.3)
+  set(UCMake_VERSION ${ARG_VERSION})
   message(STATUS "find package: UCMake ${UCMake_VERSION}")
   find_package(UCMake ${UCMake_VERSION} EXACT QUIET)
   if(NOT UCMake_FOUND)
diff --git a/config/Config.cmake.in b/config/Config.cmake.in
index 0d13a82..186b940 100644
--- a/config/Config.cmake.in
+++ b/config/Config.cmake.in
@@ -1,9 +1,21 @@
-message(STATUS "config @PROJECT_NAME@ @PROJECT_VERSION@...")
+message(STATUS "config @PROJECT_NAME@ @PROJECT_VERSION@ ...")
 
 @PACKAGE_INIT@
 
 @UBPA_PACKAGE_INIT@
 
-include ( "${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake" )
+if(@Ubpa_USRefl_Build_AutoRefl@)
+  include("${CMAKE_CURRENT_LIST_DIR}/UbpaUSReflAutoRefl.cmake")
+endif()
+
+if(NOT @Ubpa_USRefl_UseNameof@)
+  CPMAddPackage(
+    NAME nameof
+    GITHUB_REPOSITORY Neargye/nameof
+    GIT_TAG 0e8bec0
+  )
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
 
 message(STATUS "config @PROJECT_NAME@ @PROJECT_VERSION@ done")
diff --git a/include/UECS/AccessTypeID.h b/include/UECS/AccessTypeID.h
new file mode 100644
index 0000000..51dd699
--- /dev/null
+++ b/include/UECS/AccessTypeID.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "CmptTag.h"
+
+#include "detail/Util.h"
+
+#include <UTemplate/TypeID.h>
+
+#include <set>
+
+namespace Ubpa::UECS {
+	// TypeID with AccessMode
+	class AccessTypeID : public TypeID {
+	public:
+		using TypeID::TypeID; // AccessMode::WRITE
+
+		constexpr AccessTypeID(std::size_t ID, AccessMode mode) noexcept : TypeID{ ID }, mode{ mode } {}
+		constexpr AccessTypeID(std::string_view type_name, AccessMode mode) noexcept : TypeID{ type_name }, mode{ mode } {}
+		constexpr AccessTypeID(TypeID ID, AccessMode mode = AccessMode::WRITE) noexcept : TypeID{ ID }, mode{ mode } {}
+		template<std::size_t N>
+		constexpr AccessTypeID(const char(&str)[N], AccessMode mode) noexcept : TypeID{ str }, mode{ mode } {}
+
+		constexpr AccessMode GetAccessMode() const noexcept { return mode; }
+	private:
+		AccessMode mode{ AccessMode::WRITE };
+	};
+
+	template<typename Cmpt>
+	static constexpr AccessTypeID AccessTypeID_of = { TypeID_of<RemoveTag_t<Cmpt>>, AccessMode_of<Cmpt> };
+
+	using AccessTypeIDSet = std::set<AccessTypeID, std::less<>>;
+}
+
+#include "detail/AccessTypeID.inl"
diff --git a/include/UECS/ArchetypeFilter.h b/include/UECS/ArchetypeFilter.h
index dea9d53..5052b5c 100644
--- a/include/UECS/ArchetypeFilter.h
+++ b/include/UECS/ArchetypeFilter.h
@@ -1,19 +1,19 @@
 #pragma once
 
-#include "CmptType.h"
+#include "AccessTypeID.h"
 
 #include <set>
 
 namespace Ubpa::UECS {
 	// filter Archetype with all, any and none
 	struct ArchetypeFilter {
-		CmptAccessTypeSet all;
-		CmptAccessTypeSet any;
-		std::set<CmptType> none;
+		AccessTypeIDSet all;
+		AccessTypeIDSet any;
+		std::set<TypeID> none;
 
-		size_t HashCode() const noexcept;
+		std::size_t GetValue() const noexcept;
 
-		bool HaveWriteCmptType() const noexcept;
+		bool HaveWriteTypeID() const noexcept;
 
 		bool operator==(const ArchetypeFilter& rhs) const noexcept;
 	};
diff --git a/include/UECS/ChunkView.h b/include/UECS/ChunkView.h
index 32021b5..a4691af 100644
--- a/include/UECS/ChunkView.h
+++ b/include/UECS/ChunkView.h
@@ -1,30 +1,31 @@
 #pragma once
 
-#include "CmptType.h"
+#include "AccessTypeID.h"
+#include "Entity.h"
 
-#include <UContainer/Span.h>
+#include <span>
 
 namespace Ubpa::UECS {
 	class Archetype;
 
 	class ChunkView {
 	public:
-		ChunkView(Archetype* archetype, size_t chunkIdx) noexcept;
+		ChunkView(Archetype* archetype, std::size_t chunkIdx) noexcept;
 		ChunkView() noexcept = default;
 
-		bool Contains(CmptType) const;
-		size_t EntityNum() const noexcept { return entityNum; }
+		bool Contains(TypeID) const;
+		std::size_t EntityNum() const noexcept { return entityNum; }
 
 		// nullptr if not contain
-		void* GetCmptArray(CmptType) const;
+		void* GetCmptArray(TypeID) const;
 		template<typename Cmpt>
-		Span<Cmpt> GetCmptArray() const;
-		Span<const Entity> GetEntityArray() const;
+		std::span<Cmpt> GetCmptArray() const;
+		std::span<const Entity> GetEntityArray() const;
 
 	private:
 		Archetype* archetype{ nullptr };
-		size_t chunkIdx{ static_cast<size_t>(-1) };
-		size_t entityNum{ 0 };
+		std::size_t chunkIdx{ static_cast<std::size_t>(-1) };
+		std::size_t entityNum{ 0 };
 	};
 }
 
diff --git a/include/UECS/CmptLocator.h b/include/UECS/CmptLocator.h
index 3226e99..2b732c6 100644
--- a/include/UECS/CmptLocator.h
+++ b/include/UECS/CmptLocator.h
@@ -1,18 +1,17 @@
 #pragma once
 
 #include "CmptTag.h"
+#include "AccessTypeID.h"
 
-#include "CmptType.h"
-
-#include <UContainer/Span.h>
+#include <span>
 
 namespace Ubpa::UECS {
 	// locate components in function's argument list for Archetype
 	// immutable
 	class CmptLocator {
 	public:
-		CmptLocator(Span<const CmptAccessType> types);
-		CmptLocator(CmptAccessTypeSet types);
+		CmptLocator(std::span<const AccessTypeID> types);
+		CmptLocator(AccessTypeIDSet types);
 
 		CmptLocator();
 
@@ -22,19 +21,19 @@ namespace Ubpa::UECS {
 		template<typename Func>
 		CmptLocator& Combine();
 
-		size_t HashCode() const noexcept { return hashCode; }
+		std::size_t GetValue() const noexcept { return hashCode; }
 
-		const CmptAccessTypeSet& CmptAccessTypes() const noexcept { return cmptTypes; }
+		const AccessTypeIDSet& AccessTypeIDs() const noexcept { return cmptTypes; }
 
 		bool operator==(const CmptLocator& rhs) const noexcept;
 
-		bool HasWriteCmptType() const noexcept;
+		bool HasWriteTypeID() const noexcept;
 	private:
-		void UpdateHashCode() noexcept;
+		void UpdateGetValue() noexcept;
 
-		CmptAccessTypeSet cmptTypes;
+		AccessTypeIDSet cmptTypes;
 
-		size_t hashCode;
+		std::size_t hashCode;
 	};
 }
 
diff --git a/include/UECS/CmptPtr.h b/include/UECS/CmptPtr.h
index 3f56133..d69a41f 100644
--- a/include/UECS/CmptPtr.h
+++ b/include/UECS/CmptPtr.h
@@ -1,50 +1,50 @@
 #pragma once
 
-#include "CmptType.h"
+#include "AccessTypeID.h"
 
 #include <cassert>
 
 namespace Ubpa::UECS {
-	// CmptType + void*
+	// TypeID + void*
 	class CmptPtr {
 	public:
-		constexpr CmptPtr(CmptType type, void* p) noexcept : type{ type }, p{ p } {}
+		constexpr CmptPtr(TypeID type, void* p) noexcept : type{ type }, p{ p } {}
 		template<typename Cmpt>
-		constexpr CmptPtr(Cmpt* p) noexcept : type{ CmptType::Of<Cmpt> }, p{ p } {}
+		constexpr CmptPtr(Cmpt* p) noexcept : type{ TypeID_of<Cmpt> }, p{ p } {}
 		constexpr CmptPtr() noexcept : CmptPtr{ Invalid() } {}
 
 		constexpr void* Ptr() const noexcept { return p; }
 
-		constexpr CmptType Type() const noexcept { return type; }
+		constexpr TypeID Type() const noexcept { return type; }
 
-		static constexpr CmptPtr Invalid() noexcept { return { CmptType::Invalid(), nullptr }; };
+		static constexpr CmptPtr Invalid() noexcept { return { TypeID{}, nullptr }; };
 		constexpr bool Valid() const noexcept { return p != nullptr && type.Valid(); }
 
 		template<typename Cmpt>
 		constexpr Cmpt* As() const noexcept { return reinterpret_cast<Cmpt*>(p); }
 	private:
-		CmptType type;
+		TypeID type;
 		void* p;
 	};
 
-	// CmptAccessType + void*
+	// AccessTypeID + void*
 	class CmptAccessPtr {
 	public:
-		constexpr CmptAccessPtr(CmptType type, void* p, AccessMode mode) noexcept : accessType{ type, mode }, p{ p } {}
-		constexpr CmptAccessPtr(CmptAccessType accessType, void* p) noexcept : accessType{ accessType }, p{ p } {}
+		constexpr CmptAccessPtr(TypeID type, void* p, AccessMode mode) noexcept : accessType{ type, mode }, p{ p } {}
+		constexpr CmptAccessPtr(AccessTypeID accessType, void* p) noexcept : accessType{ accessType }, p{ p } {}
 		constexpr CmptAccessPtr(CmptPtr p, AccessMode mode) noexcept : accessType{ p.Type(), mode }, p{ p.Ptr() } {}
 		template<typename TaggedCmpt>
-		constexpr CmptAccessPtr(TaggedCmpt p) noexcept : accessType{ CmptAccessType::Of<TaggedCmpt> }, p{ CastToVoidPointer(p) } {}
+		constexpr CmptAccessPtr(TaggedCmpt p) noexcept : accessType{ AccessTypeID_of<TaggedCmpt> }, p{ CastToVoidPointer(p) } {}
 		explicit constexpr CmptAccessPtr(CmptPtr p) noexcept : CmptAccessPtr{ p, AccessMode::LATEST } {}
 		explicit constexpr CmptAccessPtr() noexcept : CmptAccessPtr{ Invalid() } {}
 
-		explicit constexpr operator CmptPtr() const noexcept { return { CmptType{accessType}, p }; }
+		explicit constexpr operator CmptPtr() const noexcept { return { TypeID{accessType}, p }; }
 
 		constexpr void* Ptr() const noexcept { return p; }
 
-		constexpr CmptAccessType AccessType() const noexcept { return accessType; }
+		constexpr AccessTypeID AccessType() const noexcept { return accessType; }
 
-		static constexpr CmptAccessPtr Invalid() noexcept { return { CmptAccessType::Invalid(), nullptr }; };
+		static constexpr CmptAccessPtr Invalid() noexcept { return { AccessTypeID{}, nullptr }; };
 		constexpr bool Valid() const noexcept { return p != nullptr && accessType.Valid(); }
 
 		// check: type's access mode must be equal to <mode>
@@ -62,7 +62,7 @@ namespace Ubpa::UECS {
 		}
 	private:
 		friend class EntityMngr;
-		CmptAccessType accessType;
+		AccessTypeID accessType;
 		void* p;
 	};
 }
diff --git a/include/UECS/CmptTag.h b/include/UECS/CmptTag.h
index b410002..87e3d99 100644
--- a/include/UECS/CmptTag.h
+++ b/include/UECS/CmptTag.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstddef>
+
 namespace Ubpa::UECS {
 	// read/write tag : LastFrame -> Write -> Latest
 	// singleton tag  : Singleton
@@ -11,7 +13,7 @@ namespace Ubpa::UECS {
 	// 5. Write<Singleton<Cmpt>> == Singleton<Cmpt>
 	// 6. Latest<Singleton<Cmpt>>
 
-	enum class AccessMode : size_t {
+	enum class AccessMode : std::size_t {
 		LAST_FRAME           = 0b000, // LastFrame<Cmpt>
 		WRITE                = 0b001, // Write<Cmpt> / Cmpt*
 		LATEST               = 0b010, // Latest<Cmpt> / const Cmpt*
diff --git a/include/UECS/CmptType.h b/include/UECS/CmptType.h
deleted file mode 100644
index 2190f97..0000000
--- a/include/UECS/CmptType.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include "CmptTag.h"
-
-#include "detail/Util.h"
-
-#include <UTemplate/TypeID.h>
-
-#include <set>
-
-namespace Ubpa::UECS {
-	// Component Type
-	// use a hashcode to distinguish different type
-	class CmptType {
-	public:
-		explicit constexpr CmptType(size_t id) noexcept : hashcode{ id } {}
-		explicit constexpr CmptType(std::string_view type_name) noexcept : hashcode{ RuntimeTypeID(type_name) } {}
-		explicit constexpr CmptType() noexcept : CmptType{ Invalid() } {}
-
-		template<typename Cmpt, std::enable_if_t<!IsTaggedCmpt_v<Cmpt>, int> = 0>
-		static constexpr CmptType Of = CmptType{ TypeID<Cmpt> };
-
-		constexpr size_t HashCode() const noexcept { return hashcode; }
-
-		static constexpr CmptType Invalid() noexcept { return CmptType{ static_cast<size_t>(-1) }; }
-		constexpr bool Valid() const noexcept { return hashcode == static_cast<size_t>(-1); }
-
-		template<typename Cmpt>
-		constexpr bool Is() const noexcept { return operator==(Of<Cmpt>); }
-		constexpr bool Is(std::string_view type_name) const noexcept { return operator==(CmptType{ type_name }); }
-
-		constexpr bool operator< (const CmptType& rhs) const noexcept { return hashcode <  rhs.hashcode; }
-		constexpr bool operator<=(const CmptType& rhs) const noexcept { return hashcode <= rhs.hashcode; }
-		constexpr bool operator> (const CmptType& rhs) const noexcept { return hashcode >  rhs.hashcode; }
-		constexpr bool operator>=(const CmptType& rhs) const noexcept { return hashcode >= rhs.hashcode; }
-		constexpr bool operator==(const CmptType& rhs) const noexcept { return hashcode == rhs.hashcode; }
-		constexpr bool operator!=(const CmptType& rhs) const noexcept { return hashcode != rhs.hashcode; }
-	private:
-		size_t hashcode;
-	};
-
-	// CmptType with AccessMode
-	class CmptAccessType {
-	public:
-		constexpr CmptAccessType(size_t id, AccessMode mode = AccessMode::WRITE) noexcept
-			: type{ id }, mode{ mode } {}
-		constexpr CmptAccessType(std::string_view type_name, AccessMode mode = AccessMode::WRITE) noexcept
-			: type{ RuntimeTypeID(type_name) }, mode{ mode } {}
-		constexpr CmptAccessType(CmptType type, AccessMode mode = AccessMode::WRITE) noexcept
-			: type{ type }, mode{ mode } {}
-		explicit constexpr CmptAccessType() noexcept : CmptAccessType{ Invalid() } {}
-
-		template<typename Cmpt>
-		static constexpr CmptAccessType Of = CmptAccessType{ CmptType::Of<RemoveTag_t<Cmpt>>, AccessModeOf<Cmpt> };
-
-		// same with CmptType's HashCode
-		constexpr size_t HashCode() const noexcept { return type.HashCode(); }
-		constexpr CmptType GetCmptType() const noexcept { return type; }
-		constexpr AccessMode GetAccessMode() const noexcept { return mode; }
-
-		constexpr operator CmptType() const noexcept { return type; }
-
-		static constexpr CmptAccessType Invalid() noexcept { return CmptAccessType{ static_cast<size_t>(-1), AccessMode{} }; }
-		constexpr bool Valid() const noexcept { return type.Valid(); }
-
-		// same with CmptType's operator<
-		constexpr bool operator< (const CmptAccessType& rhs) const noexcept { return type <  rhs.type; }
-		constexpr bool operator<=(const CmptAccessType& rhs) const noexcept { return type <= rhs.type; }
-		constexpr bool operator> (const CmptAccessType& rhs) const noexcept { return type >  rhs.type; }
-		constexpr bool operator>=(const CmptAccessType& rhs) const noexcept { return type >= rhs.type; }
-		constexpr bool operator==(const CmptAccessType& rhs) const noexcept { return type == rhs.type; }
-		constexpr bool operator!=(const CmptAccessType& rhs) const noexcept { return type != rhs.type; }
-
-		constexpr bool operator< (const CmptType& rhs) const noexcept { return type <  rhs; }
-		constexpr bool operator<=(const CmptType& rhs) const noexcept { return type <= rhs; }
-		constexpr bool operator> (const CmptType& rhs) const noexcept { return type >  rhs; }
-		constexpr bool operator>=(const CmptType& rhs) const noexcept { return type >= rhs; }
-		constexpr bool operator==(const CmptType& rhs) const noexcept { return type == rhs; }
-		constexpr bool operator!=(const CmptType& rhs) const noexcept { return type != rhs; }
-
-		friend constexpr bool operator< (const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs <  rhs.type; }
-		friend constexpr bool operator<=(const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs <= rhs.type; }
-		friend constexpr bool operator> (const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs >  rhs.type; }
-		friend constexpr bool operator>=(const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs >= rhs.type; }
-		friend constexpr bool operator==(const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs == rhs.type; }
-		friend constexpr bool operator!=(const CmptType& lhs, const CmptAccessType& rhs) noexcept { return lhs != rhs.type; }
-	private:
-		CmptType type;
-		AccessMode mode;
-	};
-
-	using CmptAccessTypeSet = std::set<CmptAccessType, std::less<>>;
-}
-
-#include "detail/CmptType.inl"
diff --git a/include/UECS/CmptsView.h b/include/UECS/CmptsView.h
index 8527eff..c8d76bb 100644
--- a/include/UECS/CmptsView.h
+++ b/include/UECS/CmptsView.h
@@ -1,17 +1,18 @@
 #pragma once
 
 #include "CmptPtr.h"
-#include <UContainer/Span.h>
+
+#include <span>
 
 namespace Ubpa::UECS {
 	class CmptsView {
 	public:
 		CmptsView() noexcept = default;
-		CmptsView(Span<const CmptAccessPtr> cmpts) noexcept : cmpts{ cmpts } {}
+		CmptsView(std::span<const CmptAccessPtr> cmpts) noexcept : cmpts{ cmpts } {}
 
-		CmptAccessPtr GetCmpt(CmptAccessType) const noexcept;
-		Span<const CmptAccessPtr> Components() const noexcept { return cmpts; }
+		CmptAccessPtr GetCmpt(AccessTypeID) const noexcept;
+		std::span<const CmptAccessPtr> Components() const noexcept { return cmpts; }
 	private:
-		Span<const CmptAccessPtr> cmpts;
+		std::span<const CmptAccessPtr> cmpts;
 	};
 }
diff --git a/include/UECS/Entity.h b/include/UECS/Entity.h
index 547bd97..5c4f437 100644
--- a/include/UECS/Entity.h
+++ b/include/UECS/Entity.h
@@ -6,12 +6,12 @@ namespace Ubpa::UECS {
 	// index + version
 	class Entity {
 	public:
-		constexpr Entity(size_t idx, size_t version) noexcept : idx(idx), version(version) {}
+		constexpr Entity(std::size_t idx, std::size_t version) noexcept : idx(idx), version(version) {}
 		constexpr Entity() noexcept : Entity{ Invalid() } {}
-		constexpr size_t Idx() const noexcept { return idx; }
-		constexpr size_t Version() const noexcept { return version; }
-		static constexpr Entity Invalid() noexcept { return { static_cast<size_t>(-1),static_cast<size_t>(-1) }; }
-		constexpr bool Valid() const noexcept { return idx != static_cast<size_t>(-1); }
+		constexpr std::size_t Idx() const noexcept { return idx; }
+		constexpr std::size_t Version() const noexcept { return version; }
+		static constexpr Entity Invalid() noexcept { return { static_cast<std::size_t>(-1),static_cast<std::size_t>(-1) }; }
+		constexpr bool Valid() const noexcept { return idx != static_cast<std::size_t>(-1); }
 		constexpr bool operator==(const Entity& rhs) const noexcept {
 			return idx == rhs.idx && version == rhs.version;
 		}
@@ -20,7 +20,7 @@ namespace Ubpa::UECS {
 		}
 	private:
 		friend class EntityMngr;
-		size_t idx;
-		size_t version;
+		std::size_t idx;
+		std::size_t version;
 	};
 }
diff --git a/include/UECS/EntityMngr.h b/include/UECS/EntityMngr.h
index e13b9b1..57580bb 100644
--- a/include/UECS/EntityMngr.h
+++ b/include/UECS/EntityMngr.h
@@ -5,6 +5,8 @@
 #include "EntityQuery.h"
 #include "SingletonLocator.h"
 
+#include <memory_resource>
+
 namespace Ubpa::UECS {
 	class World;
 	class SystemFunc;
@@ -18,7 +20,7 @@ namespace Ubpa::UECS {
 	// - Singleton: IsSingleton, GetSingletonEntity, GetSingleton
 	// - other: EntityNum, AddCommand
 	// [important]
-	// - some API with CmptType need RTDCmptTraits to get {size|alignment|lifecycle function} (throw std::logic_error)
+	// - some API with TypeID need RTDCmptTraits to get {size|alignment|lifecycle function} (throw std::logic_error)
 	// - API with Entity require Entity exist  (throw std::invalid_argument)
 	// [details]
 	// - when free entries is empty, use new entity entry (version is 0)
@@ -35,8 +37,8 @@ namespace Ubpa::UECS {
 		std::tuple<Entity, Cmpts*...> Create();
 
 		// use RTDCmptTraits
-		Entity Create(Span<const CmptType> types);
-		Entity Create(CmptType type) { return Create({ &type, 1 }); }
+		Entity Create(std::span<const TypeID> types);
+		Entity Create(TypeID type) { return Create({ &type, 1 }); }
 
 		Entity Instantiate(Entity);
 
@@ -46,26 +48,26 @@ namespace Ubpa::UECS {
 		std::tuple<Cmpts*...> Attach(Entity);
 
 		// use RTDCmptTraits
-		void Attach(Entity, Span<const CmptType> types);
-		void Attach(Entity e, CmptType type) { Attach(e, { &type, 1 }); }
+		void Attach(Entity, std::span<const TypeID> types);
+		void Attach(Entity e, TypeID type) { Attach(e, { &type, 1 }); }
 
 		template<typename Cmpt, typename... Args>
 		Cmpt* Emplace(Entity, Args&&...);
 
-		void Detach(Entity, Span<const CmptType> types);
-		void Detach(Entity e, CmptType type) { Detach(e, { &type, 1 }); }
-		// use Detach(Entity, const CmptType*, size_t)
+		void Detach(Entity, std::span<const TypeID> types);
+		void Detach(Entity e, TypeID type) { Detach(e, { &type, 1 }); }
+		// use Detach(Entity, const TypeID*, std::size_t)
 		template<typename... Cmpts>
 		void Detach(Entity);
 
-		bool Have(Entity, CmptType) const;
-		// use Have(Entity, CmptType)
+		bool Have(Entity, TypeID) const;
+		// use Have(Entity, TypeID)
 		template<typename Cmpt>
 		bool Have(Entity) const;
 
-		// nullptr if not containts CmptType
-		CmptPtr Get(Entity, CmptType) const;
-		// use Get(Entity, CmptType)
+		// nullptr if not containts TypeID
+		CmptPtr Get(Entity, TypeID) const;
+		// use Get(Entity, TypeID)
 		template<typename Cmpt>
 		Cmpt* Get(Entity) const;
 
@@ -75,23 +77,23 @@ namespace Ubpa::UECS {
 
 		void Destroy(Entity);
 
-		size_t TotalEntityNum() const noexcept { return entityTable.size() - entityTableFreeEntry.size(); }
-		size_t EntityNum(const EntityQuery&) const;
+		std::size_t TotalEntityNum() const noexcept { return entityTable.size() - entityTableFreeEntry.size(); }
+		std::size_t EntityNum(const EntityQuery&) const;
 		// use entry in reverse
-		const std::vector<size_t>& GetEntityFreeEntries() const noexcept { return entityTableFreeEntry; }
-		size_t GetEntityVersion(size_t idx) const noexcept { return entityTable.at(idx).version; }
+		const std::vector<std::size_t>& GetEntityFreeEntries() const noexcept { return entityTableFreeEntry; }
+		std::size_t GetEntityVersion(std::size_t idx) const noexcept { return entityTable.at(idx).version; }
 
-		bool IsSingleton(CmptType) const;
-		Entity GetSingletonEntity(CmptType) const;
+		bool IsSingleton(TypeID) const;
+		Entity GetSingletonEntity(TypeID) const;
 		// nullptr if not singleton
-		CmptPtr GetSingleton(CmptType) const;
+		CmptPtr GetSingleton(TypeID) const;
 		template<typename Cmpt>
-		Cmpt* GetSingleton() const { return GetSingleton(CmptType::Of<Cmpt>).As<Cmpt>(); }
+		Cmpt* GetSingleton() const { return GetSingleton(TypeID_of<Cmpt>).As<Cmpt>(); }
 
 		// filter's all contains cmpt
 		template<typename Cmpt>
 		std::vector<Cmpt*> GetCmptArray(const ArchetypeFilter&) const;
-		std::vector<CmptPtr> GetCmptArray(const ArchetypeFilter&, CmptType) const;
+		std::vector<CmptPtr> GetCmptArray(const ArchetypeFilter&, TypeID) const;
 		std::vector<Entity> GetEntityArray(const ArchetypeFilter&) const;
 
 		void Accept(IListener* listener) const;
@@ -102,17 +104,17 @@ namespace Ubpa::UECS {
 		friend class World;
 		friend class Archetype;
 
-		static bool IsSet(Span<const CmptType> types) noexcept;
+		static bool IsSet(std::span<const TypeID> types) noexcept;
 
 		template<typename... Cmpts>
 		Archetype* GetOrCreateArchetypeOf();
 		// types not contain Entity
-		Archetype* GetOrCreateArchetypeOf(Span<const CmptType> types);
+		Archetype* GetOrCreateArchetypeOf(std::span<const TypeID> types);
 
 		// return original archetype
 		template<typename... Cmpts>
 		Archetype* AttachWithoutInit(Entity);
-		Archetype* AttachWithoutInit(Entity, Span<const CmptType> types);
+		Archetype* AttachWithoutInit(Entity, std::span<const TypeID> types);
 
 		std::vector<CmptAccessPtr> LocateSingletons(const SingletonLocator&) const;
 
@@ -130,16 +132,16 @@ namespace Ubpa::UECS {
 
 		struct EntityInfo {
 			Archetype* archetype{ nullptr };
-			size_t idxInArchetype{ static_cast<size_t>(-1) };
-			size_t version{ 0 }; // version
+			std::size_t idxInArchetype{ static_cast<std::size_t>(-1) };
+			std::size_t version{ 0 }; // version
 		};
 		std::vector<EntityInfo> entityTable;
-		std::vector<size_t> entityTableFreeEntry;
-		size_t RequestEntityFreeEntry();
+		std::vector<std::size_t> entityTableFreeEntry;
+		std::size_t RequestEntityFreeEntry();
 		void RecycleEntityEntry(Entity);
 
-		std::unique_ptr<Pool<Chunk>> sharedChunkPool;
-		std::unordered_map<CmptTypeSet, std::unique_ptr<Archetype>> ts2a; // archetype's CmptTypeSet to archetype
+		std::unique_ptr<std::pmr::unsynchronized_pool_resource> rsrc;
+		std::unordered_map<TypeIDSet, std::unique_ptr<Archetype>> ts2a; // archetype's TypeIDSet to archetype
 	};
 }
 
diff --git a/include/UECS/EntityQuery.h b/include/UECS/EntityQuery.h
index 88f36ed..bd2130b 100644
--- a/include/UECS/EntityQuery.h
+++ b/include/UECS/EntityQuery.h
@@ -10,7 +10,7 @@ namespace Ubpa::UECS {
 		ArchetypeFilter filter;
 		CmptLocator locator;
 
-		size_t HashCode() const noexcept { return hash_combine(filter.HashCode(), locator.HashCode()); }
+		std::size_t GetValue() const noexcept { return hash_combine(filter.GetValue(), locator.GetValue()); }
 
 		bool operator==(const EntityQuery& query) const noexcept {
 			return filter == query.filter && locator == query.locator;
diff --git a/include/UECS/RTDCmptTraits.h b/include/UECS/RTDCmptTraits.h
index fa4ee91..ec39e50 100644
--- a/include/UECS/RTDCmptTraits.h
+++ b/include/UECS/RTDCmptTraits.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "CmptType.h"
+#include "AccessTypeID.h"
 
 #include <unordered_map>
 #include <functional>
@@ -18,18 +18,18 @@ namespace Ubpa::UECS {
 	// - name
 	class RTDCmptTraits {
 	public:
-		static constexpr size_t DefaultAlignment() noexcept { return alignof(std::max_align_t); }
+		static constexpr std::size_t DefaultAlignment() noexcept { return alignof(std::max_align_t); }
 
 		RTDCmptTraits& Clear();
 
-		RTDCmptTraits& RegisterSize(CmptType, size_t size);
-		RTDCmptTraits& RegisterAlignment(CmptType, size_t alignment);
-		RTDCmptTraits& RegisterDefaultConstructor(CmptType, std::function<void(void*)>);
-		RTDCmptTraits& RegisterCopyConstructor(CmptType, std::function<void(void*,void*)>);
-		RTDCmptTraits& RegisterMoveConstructor(CmptType, std::function<void(void*,void*)>);
-		RTDCmptTraits& RegisterMoveAssignment(CmptType, std::function<void(void*,void*)>);
-		RTDCmptTraits& RegisterDestructor(CmptType, std::function<void(void*)>);
-		RTDCmptTraits& RegisterName(CmptType, std::string name);
+		RTDCmptTraits& RegisterSize(TypeID, std::size_t size);
+		RTDCmptTraits& RegisterAlignment(TypeID, std::size_t alignment);
+		RTDCmptTraits& RegisterDefaultConstructor(TypeID, std::function<void(void*)>);
+		RTDCmptTraits& RegisterCopyConstructor(TypeID, std::function<void(void*,void*)>);
+		RTDCmptTraits& RegisterMoveConstructor(TypeID, std::function<void(void*,void*)>);
+		RTDCmptTraits& RegisterMoveAssignment(TypeID, std::function<void(void*,void*)>);
+		RTDCmptTraits& RegisterDestructor(TypeID, std::function<void(void*)>);
+		RTDCmptTraits& RegisterName(TypeID, std::string name);
 
 		const auto& GetSizeofs() const noexcept { return sizeofs; }
 		const auto& GetAlignments() const noexcept { return alignments; };
@@ -40,16 +40,16 @@ namespace Ubpa::UECS {
 		const auto& GetDestructors() const noexcept { return destructors; }
 		const auto& GetNames() const noexcept { return names; }
 
-		size_t Sizeof(CmptType) const;
-		size_t Alignof(CmptType) const;
-		void DefaultConstruct(CmptType, void* cmpt) const;
-		void CopyConstruct(CmptType, void* dst, void* src) const;
-		void MoveConstruct(CmptType, void* dst, void* src) const;
-		void MoveAssign(CmptType, void* dst, void* src) const;
-		void Destruct(CmptType, void* cmpt) const;
-		std::string_view Nameof(CmptType) const;
+		std::size_t Sizeof(TypeID) const;
+		std::size_t Alignof(TypeID) const;
+		void DefaultConstruct(TypeID, void* cmpt) const;
+		void CopyConstruct(TypeID, void* dst, void* src) const;
+		void MoveConstruct(TypeID, void* dst, void* src) const;
+		void MoveAssign(TypeID, void* dst, void* src) const;
+		void Destruct(TypeID, void* cmpt) const;
+		std::string_view Nameof(TypeID) const;
 
-		RTDCmptTraits& Deregister(CmptType) noexcept;
+		RTDCmptTraits& Deregister(TypeID) noexcept;
 
 		template<typename... Cmpts>
 		void Register();
@@ -68,14 +68,14 @@ namespace Ubpa::UECS {
 		template<typename Cmpt>
 		void RegisterOne();
 
-		std::unordered_map<CmptType, size_t> sizeofs;
-		std::unordered_map<CmptType, size_t> alignments;
-		std::unordered_map<CmptType, std::function<void(void*)>> default_constructors; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> copy_constructors; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> move_constructors; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> move_assignments; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*)>> destructors;
-		std::unordered_map<CmptType, std::string> names;
+		std::unordered_map<TypeID, std::size_t> sizeofs;
+		std::unordered_map<TypeID, std::size_t> alignments;
+		std::unordered_map<TypeID, std::function<void(void*)>> default_constructors; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> copy_constructors; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> move_constructors; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> move_assignments; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*)>> destructors;
+		std::unordered_map<TypeID, std::string> names;
 	};
 }
 
diff --git a/include/UECS/RandomAccessor.h b/include/UECS/RandomAccessor.h
index eccbcf2..cba73a0 100644
--- a/include/UECS/RandomAccessor.h
+++ b/include/UECS/RandomAccessor.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "CmptType.h"
+#include "AccessTypeID.h"
 
 #include <set>
 
 namespace Ubpa::UECS {
 	class RandomAccessor {
 	public:
-		CmptAccessTypeSet types;
+		AccessTypeIDSet types;
 	};
 }
diff --git a/include/UECS/Schedule.h b/include/UECS/Schedule.h
index 2f00434..b368302 100644
--- a/include/UECS/Schedule.h
+++ b/include/UECS/Schedule.h
@@ -3,9 +3,9 @@
 #include "detail/SystemFunc.h"
 #include "detail/Job.h"
 
-#include <UContainer/Pool.h>
-
 #include <map>
+#include <memory>
+#include <memory_resource>
 
 namespace Ubpa::UECS::detail {
 	struct Compiler;
@@ -25,12 +25,16 @@ namespace Ubpa::UECS {
 	// schedule will be clear at the beginning of the next World::Update()
 	class Schedule {
 	public:
+		Schedule() :
+			rsrc{std::make_unique<std::pmr::unsynchronized_pool_resource>()},
+			sysFuncAllocator{ rsrc.get() } {}
+
 		// Func's argument list:
 		// [const] World*
 		// {LastFrame|Latest}<Singleton<Cmpt>>
 		// SingletonsView
 		// Entity
-		// size_t indexInQuery
+		// std::size_t indexInQuery
 		// <tagged-components>: {LastFrame|Write|Latest}<Cmpt>...
 		// CmptsView
 		template<typename Func>
@@ -79,8 +83,8 @@ namespace Ubpa::UECS {
 
 		Schedule& LockFilter(std::string_view sys);
 
-		Schedule& InsertNone(std::string_view sys, CmptType);
-		Schedule& EraseNone(std::string_view sys, CmptType);
+		Schedule& InsertNone(std::string_view sys, TypeID);
+		Schedule& EraseNone(std::string_view sys, TypeID);
 
 	private:
 		template<typename... Args>
@@ -94,27 +98,28 @@ namespace Ubpa::UECS {
 			std::vector<SystemFunc*> latestSysFuncs;
 		};
 		friend struct detail::Compiler;
-		std::unordered_map<CmptType, CmptSysFuncs> GenCmptSysFuncsMap() const;
+		std::unordered_map<TypeID, CmptSysFuncs> GenCmptSysFuncsMap() const;
 
 		SysFuncGraph GenSysFuncGraph() const;
 
 		// SystemFunc's hashcode to pointer of SystemFunc
-		std::unordered_map<size_t, SystemFunc*> sysFuncs;
+		std::unordered_map<std::size_t, SystemFunc*> sysFuncs;
 
 		// SystemFunc's hashcode to SystemFunc's hashcode
 		// parent to children
-		std::unordered_map<size_t, size_t> sysFuncOrder;
+		std::unordered_map<std::size_t, std::size_t> sysFuncOrder;
 
 		struct FilterChange {
-			std::set<CmptType> insertNones;
-			std::set<CmptType> eraseNones;
+			std::set<TypeID> insertNones;
+			std::set<TypeID> eraseNones;
 		};
-		std::unordered_map<size_t, FilterChange> sysFilterChange;
-		std::unordered_set<size_t> sysLockFilter;
+		std::unordered_map<std::size_t, FilterChange> sysFilterChange;
+		std::unordered_set<std::size_t> sysLockFilter;
 
 		std::map<int, std::vector<std::function<void(World*)>>> commandBuffer;
 
-		Pool<SystemFunc> sysFuncPool;
+		std::unique_ptr<std::pmr::unsynchronized_pool_resource> rsrc;
+		std::pmr::polymorphic_allocator<SystemFunc> sysFuncAllocator;
 		friend class World;
 	};
 }
diff --git a/include/UECS/SingletonLocator.h b/include/UECS/SingletonLocator.h
index 9bc317f..7d1b5d0 100644
--- a/include/UECS/SingletonLocator.h
+++ b/include/UECS/SingletonLocator.h
@@ -1,16 +1,15 @@
 #pragma once
 
-#include "CmptType.h"
-
-#include <UContainer/Span.h>
+#include "AccessTypeID.h"
 
 #include <set>
+#include <span>
 
 namespace Ubpa::UECS {
 	class SingletonLocator {
 	public:
-		SingletonLocator(std::set<CmptAccessType> types) : singletonTypes{ std::move(types) } {}
-		SingletonLocator(Span<const CmptAccessType> types);
+		SingletonLocator(std::set<AccessTypeID> types) : singletonTypes{ std::move(types) } {}
+		SingletonLocator(std::span<const AccessTypeID> types);
 		SingletonLocator() = default;
 
 		template<typename Func>
@@ -19,12 +18,12 @@ namespace Ubpa::UECS {
 		template<typename Func>
 		SingletonLocator& Combine();
 
-		const std::set<CmptAccessType>& SingletonTypes() const noexcept { return singletonTypes; }
+		const std::set<AccessTypeID>& SingletonTypes() const noexcept { return singletonTypes; }
 
 		bool HasWriteSingletonType() const noexcept;
 
 	private:
-		std::set<CmptAccessType> singletonTypes;
+		std::set<AccessTypeID> singletonTypes;
 	};
 }
 
diff --git a/include/UECS/SingletonsView.h b/include/UECS/SingletonsView.h
index cea7006..474d3f9 100644
--- a/include/UECS/SingletonsView.h
+++ b/include/UECS/SingletonsView.h
@@ -2,17 +2,17 @@
 
 #include "CmptPtr.h"
 
-#include <UContainer/Span.h>
+#include <span>
 
 namespace Ubpa::UECS {
 	class SingletonsView {
 	public:
-		SingletonsView(Span<const CmptAccessPtr> singletons) noexcept
+		SingletonsView(std::span<const CmptAccessPtr> singletons) noexcept
 			: singletons{ singletons } {}
 
-		CmptAccessPtr GetSingleton(CmptAccessType) const noexcept;
-		Span<const CmptAccessPtr> Singletons() const noexcept { return singletons; }
+		CmptAccessPtr GetSingleton(AccessTypeID) const noexcept;
+		std::span<const CmptAccessPtr> Singletons() const noexcept { return singletons; }
 	private:
-		Span<const CmptAccessPtr> singletons;
+		std::span<const CmptAccessPtr> singletons;
 	};
 }
diff --git a/include/UECS/SystemMngr.h b/include/UECS/SystemMngr.h
index dfc119e..365d27e 100644
--- a/include/UECS/SystemMngr.h
+++ b/include/UECS/SystemMngr.h
@@ -20,21 +20,21 @@ namespace Ubpa::UECS {
 		const auto& GetActiveSystemsIDs() const noexcept { return activeSystemIDs; }
 
 		// not alive -> create
-		void Create(size_t systemID);
+		void Create(std::size_t systemID);
 		
 		// 1. not alive create -> create and activate
 		// 2. not active -> then activate
-		void Activate(size_t systemID);
+		void Activate(std::size_t systemID);
 
 		// active -> deactavate
-		void Deactivate(size_t systemID);
+		void Deactivate(std::size_t systemID);
 		
 		// 1. active -> deactavite
 		// 2. alive -> destroy
-		void Destroy(size_t systemID);
+		void Destroy(std::size_t systemID);
 
-		bool IsAlive(size_t systemID) const;
-		bool IsActive(size_t systemID) const;
+		bool IsAlive(std::size_t systemID) const;
+		bool IsActive(std::size_t systemID) const;
 
 		// [ Template ] Functions
 		///////////////////////////
@@ -58,10 +58,10 @@ namespace Ubpa::UECS {
 		bool IsActive() const { return IsActive(systemTraits.GetID<System>()); }
 
 		template<typename... Systems>
-		std::array<size_t, sizeof...(Systems)> RegisterAndCreate();
+		std::array<std::size_t, sizeof...(Systems)> RegisterAndCreate();
 
 		template<typename... Systems>
-		std::array<size_t, sizeof...(Systems)> RegisterAndActivate();
+		std::array<std::size_t, sizeof...(Systems)> RegisterAndActivate();
 
 		SystemMngr(const SystemMngr&) = delete;
 		SystemMngr(SystemMngr&&) noexcept = delete;
@@ -71,11 +71,11 @@ namespace Ubpa::UECS {
 	private:
 		friend class World;
 		World* w;
-		void Update(size_t systemID, Schedule&) const;
+		void Update(std::size_t systemID, Schedule&) const;
 		void Clear();
 		
-		std::unordered_set<size_t> aliveSystemIDs;
-		std::unordered_set<size_t> activeSystemIDs;
+		std::unordered_set<std::size_t> aliveSystemIDs;
+		std::unordered_set<std::size_t> activeSystemIDs;
 	};
 }
 
diff --git a/include/UECS/SystemTraits.h b/include/UECS/SystemTraits.h
index 4459ae6..60c8eab 100644
--- a/include/UECS/SystemTraits.h
+++ b/include/UECS/SystemTraits.h
@@ -42,18 +42,18 @@ namespace Ubpa::UECS {
 
 		// register system's name and get an ID
 		// if it is already registered, return it's ID directly
-		size_t Register(std::string name);
+		std::size_t Register(std::string name);
 
 		// ID must exist
-		void RegisterOnCreate    (size_t ID, std::function<OnCreate>);
-		void RegisterOnActivate  (size_t ID, std::function<OnActivate>);
-		void RegisterOnUpdate    (size_t ID, std::function<OnUpdate>);
-		void RegisterOnDeactivate(size_t ID, std::function<OnDeactivate>);
-		void RegisterOnDestroy   (size_t ID, std::function<OnDestroy>);
+		void RegisterOnCreate    (std::size_t ID, std::function<OnCreate>);
+		void RegisterOnActivate  (std::size_t ID, std::function<OnActivate>);
+		void RegisterOnUpdate    (std::size_t ID, std::function<OnUpdate>);
+		void RegisterOnDeactivate(std::size_t ID, std::function<OnDeactivate>);
+		void RegisterOnDestroy   (std::size_t ID, std::function<OnDestroy>);
 
-		std::string_view Nameof(size_t ID) const noexcept;
-		size_t GetID(std::string_view name) const;
-		bool IsRegistered(size_t ID) const noexcept;
+		std::string_view Nameof(std::size_t ID) const noexcept;
+		std::size_t GetID(std::string_view name) const;
+		bool IsRegistered(std::size_t ID) const noexcept;
 		const auto& GetNameIDMap() const noexcept { return name2id; }
 
 		// [ Template ] functions
@@ -66,10 +66,10 @@ namespace Ubpa::UECS {
 		// 1. Register(StaticNameof<System>())
 		// 2. RegisterOn{Create|Activate|Update|Deactivate|Destroy} if <System> has them
 		template<typename... Systems>
-		std::array<size_t, sizeof...(Systems)> Register();
+		std::array<std::size_t, sizeof...(Systems)> Register();
 
 		template<typename System>
-		size_t GetID() const { return GetID(StaticNameof<System>()); }
+		std::size_t GetID() const { return GetID(StaticNameof<System>()); }
 
 		template<typename System>
 		bool IsRegistered() const { return GetID<System>(); }
@@ -77,20 +77,20 @@ namespace Ubpa::UECS {
 	private:
 		friend class SystemMngr;
 		
-		void Create    (size_t ID, World*) const;
-		void Activate  (size_t ID, World*) const;
-		void Update    (size_t ID, Schedule&) const;
-		void Deactivate(size_t ID, World*) const;
-		void Destroy   (size_t ID, World*) const;
+		void Create    (std::size_t ID, World*) const;
+		void Activate  (std::size_t ID, World*) const;
+		void Update    (std::size_t ID, Schedule&) const;
+		void Deactivate(std::size_t ID, World*) const;
+		void Destroy   (std::size_t ID, World*) const;
 
 		std::vector<std::string> names;
-		std::unordered_map<std::string_view, size_t> name2id;
+		std::unordered_map<std::string_view, std::size_t> name2id;
 
-		std::unordered_map<size_t, std::function<OnCreate    >> createMap;
-		std::unordered_map<size_t, std::function<OnActivate  >> activateMap;
-		std::unordered_map<size_t, std::function<OnUpdate    >> updateMap;
-		std::unordered_map<size_t, std::function<OnDeactivate>> deactivateMap;
-		std::unordered_map<size_t, std::function<OnDestroy   >> destroyMap;
+		std::unordered_map<std::size_t, std::function<OnCreate    >> createMap;
+		std::unordered_map<std::size_t, std::function<OnActivate  >> activateMap;
+		std::unordered_map<std::size_t, std::function<OnUpdate    >> updateMap;
+		std::unordered_map<std::size_t, std::function<OnDeactivate>> deactivateMap;
+		std::unordered_map<std::size_t, std::function<OnDestroy   >> destroyMap;
 	};
 }
 
diff --git a/include/UECS/World.h b/include/UECS/World.h
index ecb85d8..0f206ad 100644
--- a/include/UECS/World.h
+++ b/include/UECS/World.h
@@ -15,7 +15,9 @@ namespace Ubpa::UECS {
 	// SystemMngr + EntityMngr
 	class World {
 	public:
-		World() : systemMngr{ this }{}
+		World() :
+			jobRsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() },
+			systemMngr { this } {}
 		// not copy/move schedule, so you can't use DumpUpdateJobGraph() and GenUpdateFrameGraph() before Update()
 		World(const World&);
 		World(World&&) noexcept;
@@ -49,7 +51,7 @@ namespace Ubpa::UECS {
 		// {LastFrame|Latest}<Singleton<Cmpt>>
 		// SingletonsView
 		// Entity
-		// size_t indexInQuery
+		// std::size_t indexInQuery
 		// <tagged-components>: [const] <Cmpt>*...
 		// CmptsView
 		template<typename Func>
@@ -66,7 +68,7 @@ namespace Ubpa::UECS {
 		// {LastFrame|Latest}<Singleton<Cmpt>>
 		// SingletonsView
 		// Entity
-		// size_t indexInQuery
+		// std::size_t indexInQuery
 		// <tagged-components>: const <Cmpt>*...
 		// CmptsView
 		// --
@@ -84,7 +86,7 @@ namespace Ubpa::UECS {
 		// [const] World*
 		// {LastFrame|Latest}<Singleton<Cmpt>>
 		// SingletonsView
-		// size_t entityBeginIndexInQuery
+		// std::size_t entityBeginIndexInQuery
 		// ChunkView (necessary)
 		template<typename Func>
 		void RunChunkJob(
@@ -98,7 +100,7 @@ namespace Ubpa::UECS {
 		// const World*
 		// {LastFrame|Latest}<Singleton<Cmpt>>
 		// SingletonsView
-		// size_t entityBeginIndexInQuery
+		// std::size_t entityBeginIndexInQuery
 		// ChunkView (necessary)
 		// --
 		// ArchetypeFilter's Cmpt AccessMode can't be WRITE
@@ -118,7 +120,7 @@ namespace Ubpa::UECS {
 
 		Job jobGraph;
 		std::vector<Job*> jobs;
-		Pool<Job> jobPool;
+		std::unique_ptr<std::pmr::unsynchronized_pool_resource> jobRsrc;
 
 		// command
 		std::map<int, std::vector<std::function<void()>>> commandBuffer;
diff --git a/include/UECS/config.h b/include/UECS/config.h
index ecc36ea..9fbf108 100644
--- a/include/UECS/config.h
+++ b/include/UECS/config.h
@@ -5,10 +5,10 @@ namespace Ubpa::UECS {
 
 	// Cache-Lines size is (typically) 64 bytes
 	// it has to be an exponent of 2 and >= 16
-	constexpr size_t CHUNK_ALIGNMENT = 64;
+	constexpr std::size_t CHUNK_ALIGNMENT = 64;
 
 	// 16384 bytes : 16 KB
 	// it has to be a multiple of UECS_CHUNK_ALIGNMENT and an exponent of 2
-	constexpr size_t CHUNK_SIZE = 16384;
+	constexpr std::size_t CHUNK_SIZE = 16384;
 }
 
diff --git a/include/UECS/detail/AccessTypeID.inl b/include/UECS/detail/AccessTypeID.inl
new file mode 100644
index 0000000..1170867
--- /dev/null
+++ b/include/UECS/detail/AccessTypeID.inl
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace std {
+	template<typename T>
+	struct hash;
+}
+
+template<>
+struct std::hash<Ubpa::UECS::AccessTypeID> {
+	constexpr std::size_t operator()(const Ubpa::UECS::AccessTypeID& id) const noexcept {
+		return id.GetValue();
+	}
+};
diff --git a/include/UECS/detail/Archetype.h b/include/UECS/detail/Archetype.h
index b2e9f47..eee1991 100644
--- a/include/UECS/detail/Archetype.h
+++ b/include/UECS/detail/Archetype.h
@@ -5,11 +5,9 @@
 #include "../CmptLocator.h"
 
 #include "ArchetypeCmptTraits.h"
-#include "CmptTypeSet.h"
+#include "TypeIDSet.h"
 #include "Chunk.h"
 
-#include <UContainer/Pool.h>
-
 #include <UTemplate/Typelist.h>
 
 namespace Ubpa::UECS {
@@ -19,101 +17,101 @@ namespace Ubpa::UECS {
 	// type of Entity + Components is Archetype's type
 	class Archetype {
 	public:
-		Archetype(Pool<Chunk>* chunkPool) noexcept : chunkPool{ chunkPool } {}
+		Archetype(std::pmr::polymorphic_allocator<Chunk> chunkAllocator) noexcept : chunkAllocator{ chunkAllocator } {}
 
 		// argument TypeList<Cmpts...> is for type deduction
 		// auto add Entity
 		template<typename... Cmpts>
-		Archetype(Pool<Chunk>* chunkPool, TypeList<Cmpts...>);
+		Archetype(std::pmr::polymorphic_allocator<Chunk> chunkAllocator, TypeList<Cmpts...>);
 
 		// copy
-		Archetype(Pool<Chunk>* chunkPool, const Archetype&);
+		Archetype(std::pmr::polymorphic_allocator<Chunk> chunkAllocator, const Archetype&);
 		Archetype(const Archetype&) = delete;
 
 		~Archetype();
 
 		// auto add Entity
-		static Archetype* New(RTDCmptTraits&, Pool<Chunk>* chunkPool, Span<const CmptType> types);
+		static Archetype* New(RTDCmptTraits&, std::pmr::polymorphic_allocator<Chunk> chunkAllocator, std::span<const TypeID> types);
 
 		// auto add Entity
 		template<typename... Cmpts>
 		static Archetype* Add(const Archetype* from);
-		static Archetype* Add(RTDCmptTraits&, const Archetype* from, Span<const CmptType> types);
+		static Archetype* Add(RTDCmptTraits&, const Archetype* from, std::span<const TypeID> types);
 
 		// auto add Entity
-		static Archetype* Remove(const Archetype* from, Span<const CmptType> types);
+		static Archetype* Remove(const Archetype* from, std::span<const TypeID> types);
 
 		// Entity + Components
-		std::tuple<std::vector<Entity*>, std::vector<std::vector<CmptAccessPtr>>, std::vector<size_t>>
+		std::tuple<std::vector<Entity*>, std::vector<std::vector<CmptAccessPtr>>, std::vector<std::size_t>>
 		Locate(const CmptLocator& locator) const;
 
 		// nullptr if not contains
-		void* Locate(size_t chunkIdx, CmptType) const;
+		void* Locate(std::size_t chunkIdx, TypeID) const;
 
-		Chunk* GetChunk(size_t chunkIdx) const { return chunks[chunkIdx]; }
+		Chunk* GetChunk(std::size_t chunkIdx) const { return chunks[chunkIdx]; }
 		
 		// nullptr if not contains
-		void* At(CmptType, size_t idx) const;
+		void* At(TypeID, std::size_t idx) const;
 
 		// nullptr if not contains
 		template<typename Cmpt>
-		Cmpt* At(size_t idx) const{ return reinterpret_cast<Cmpt*>(At(CmptType::Of<Cmpt>, idx)); }
+		Cmpt* At(std::size_t idx) const{ return reinterpret_cast<Cmpt*>(At(TypeID_of<Cmpt>, idx)); }
 
 		// no Entity
-		std::vector<CmptPtr> Components(size_t idx) const;
+		std::vector<CmptPtr> Components(std::size_t idx) const;
 
 		// no init
-		size_t RequestBuffer();
+		std::size_t RequestBuffer();
 
 		// init cmpts, set Entity
-		// size_t: index in archetype
+		// std::size_t: index in archetype
 		template<typename... Cmpts>
-		std::tuple<size_t, std::tuple<Cmpts*...>> Create(Entity);
+		std::tuple<std::size_t, std::tuple<Cmpts*...>> Create(Entity);
 
-		size_t Create(RTDCmptTraits&, Entity);
+		std::size_t Create(RTDCmptTraits&, Entity);
 		
 		// return index in archetype
-		size_t Instantiate(Entity, size_t srcIdx);
+		std::size_t Instantiate(Entity, std::size_t srcIdx);
 
 		// erase idx-th entity
 		// if idx != num-1, back entity will put at idx, return moved Entity's index
-		// else return static_cast<size_t>(-1)
+		// else return static_cast<std::size_t>(-1)
 		// move-assignment + destructor
-		size_t Erase(size_t idx);
+		std::size_t Erase(std::size_t idx);
 
 		// Components + Entity
-		const CmptTypeSet& GetCmptTypeSet() const noexcept { return types; }
+		const TypeIDSet& GetTypeIDSet() const noexcept { return types; }
 		const ArchetypeCmptTraits& GetArchetypeCmptTraits() const noexcept { return cmptTraits; }
 
-		size_t EntityNum() const noexcept { return entityNum; }
-		size_t EntityNumOfChunk(size_t chunkIdx) const noexcept;
-		size_t ChunkNum() const noexcept { return chunks.size(); }
-		size_t ChunkCapacity() const noexcept { return chunkCapacity; }
+		std::size_t EntityNum() const noexcept { return entityNum; }
+		std::size_t EntityNumOfChunk(std::size_t chunkIdx) const noexcept;
+		std::size_t ChunkNum() const noexcept { return chunks.size(); }
+		std::size_t ChunkCapacity() const noexcept { return chunkCapacity; }
 
 		// add Entity
-		static CmptTypeSet GenCmptTypeSet(Span<const CmptType> types);
+		static TypeIDSet GenTypeIDSet(std::span<const TypeID> types);
 		template<typename... Cmpts>
-		static CmptTypeSet GenCmptTypeSet();
+		static TypeIDSet GenTypeIDSet();
 
 	private:
 		// set type2alignment
 		// call after setting type2size and type2offset
 		void SetLayout();
 
-		size_t Offsetof(CmptType type) const { return type2offset.at(type); }
-		static bool NotContainEntity(Span<const CmptType> types) noexcept;
+		std::size_t Offsetof(TypeID type) const { return type2offset.at(type); }
+		static bool NotContainEntity(std::span<const TypeID> types) noexcept;
 
 		friend class EntityMngr;
 
-		CmptTypeSet types; // Entity + Components
+		TypeIDSet types; // Entity + Components
 		ArchetypeCmptTraits cmptTraits;
-		std::unordered_map<CmptType, size_t> type2offset; // CmptType to offset in chunk (include Entity)
+		std::unordered_map<TypeID, std::size_t> type2offset; // TypeID to offset in chunk (include Entity)
 
-		size_t chunkCapacity{ static_cast<size_t>(-1) };
-		Pool<Chunk>* chunkPool;
+		std::size_t chunkCapacity{ static_cast<std::size_t>(-1) };
+		std::pmr::polymorphic_allocator<Chunk> chunkAllocator;
 		std::vector<Chunk*> chunks;
 
-		size_t entityNum{ 0 }; // number of entities
+		std::size_t entityNum{ 0 }; // number of entities
 	};
 }
 
diff --git a/include/UECS/detail/Archetype.inl b/include/UECS/detail/Archetype.inl
index 56ef470..279ea17 100644
--- a/include/UECS/detail/Archetype.inl
+++ b/include/UECS/detail/Archetype.inl
@@ -4,10 +4,10 @@
 
 namespace Ubpa::UECS {
 	template<typename... Cmpts>
-	Archetype::Archetype(Pool<Chunk>* chunkPool, TypeList<Cmpts...>)
+	Archetype::Archetype(std::pmr::polymorphic_allocator<Chunk> chunkAllocator, TypeList<Cmpts...>)
 		:
-		types(GenCmptTypeSet<Cmpts...>()),
-		chunkPool{ chunkPool }
+		types(GenTypeIDSet<Cmpts...>()),
+		chunkAllocator{ chunkAllocator }
 	{
 		static_assert(IsSet_v<TypeList<Entity, Cmpts...>>,
 			"<Cmpts>... must be different");
@@ -21,12 +21,12 @@ namespace Ubpa::UECS {
 		static_assert(sizeof...(Cmpts) > 0);
 		static_assert(IsSet_v<TypeList<Entity, Cmpts...>>,
 			"<Cmpts>... must be different");
-		assert(!(from->types.Contains(CmptType::Of<Cmpts>) &&...));
+		assert(!(from->types.Contains(TypeID_of<Cmpts>) &&...));
 
-		Archetype* rst = new Archetype{ from->chunkPool };
+		Archetype* rst = new Archetype{ from->chunkAllocator };
 		
 		rst->types = from->types;
-		(rst->types.data.insert(CmptType::Of<Cmpts>), ...);
+		(rst->types.data.insert(TypeID_of<Cmpts>), ...);
 		rst->cmptTraits = from->cmptTraits;
 		(rst->cmptTraits.Register<Cmpts>(), ...);
 
@@ -36,35 +36,35 @@ namespace Ubpa::UECS {
 	}
 
 	template<typename... Cmpts>
-	std::tuple<size_t, std::tuple<Cmpts *...>> Archetype::Create(Entity e) {
+	std::tuple<std::size_t, std::tuple<Cmpts *...>> Archetype::Create(Entity e) {
 		static_assert((std::is_constructible_v<Cmpts> &&...),
 			"<Cmpts> isn't constructible");
 		static_assert(IsSet_v<TypeList<Entity, Cmpts...>>,
 			"<Cmpts>... must be different");
 
-		assert((types.Contains(CmptType::Of<Cmpts>) &&...) && types.data.size() == 1 + sizeof...(Cmpts));
+		assert((types.Contains(TypeID_of<Cmpts>) &&...) && types.data.size() == 1 + sizeof...(Cmpts));
 
-		size_t idx = RequestBuffer();
-		size_t idxInChunk = idx % chunkCapacity;
+		std::size_t idx = RequestBuffer();
+		std::size_t idxInChunk = idx % chunkCapacity;
 		byte* buffer = chunks[idx / chunkCapacity]->Data();
 
-		new(buffer + Offsetof(CmptType::Of<Entity>) + idxInChunk * sizeof(Entity))Entity(e);
+		new(buffer + Offsetof(TypeID_of<Entity>) + idxInChunk * sizeof(Entity))Entity(e);
 
-		std::tuple cmpts = { new(buffer + Offsetof(CmptType::Of<Cmpts>) + idxInChunk * sizeof(Cmpts))Cmpts... };
+		std::tuple cmpts = { new(buffer + Offsetof(TypeID_of<Cmpts>) + idxInChunk * sizeof(Cmpts))Cmpts... };
 
 		return { idx,cmpts };
 	}
 
 	template<typename... Cmpts>
-	CmptTypeSet Archetype::GenCmptTypeSet() {
+	TypeIDSet Archetype::GenTypeIDSet() {
 		if constexpr (sizeof...(Cmpts) > 0) {
 			static_assert(IsSet_v<TypeList<Entity, Cmpts...>>,
 				"<Cmpts>... must be different");
 
-			constexpr std::array types = { CmptType::Of<Cmpts>... };
-			return GenCmptTypeSet(types);
+			constexpr std::array types = { TypeID_of<Cmpts>... };
+			return GenTypeIDSet(types);
 		}
 		else
-			return GenCmptTypeSet({});
+			return GenTypeIDSet({});
 	}
 }
diff --git a/include/UECS/detail/ArchetypeCmptTraits.h b/include/UECS/detail/ArchetypeCmptTraits.h
index 9efcd6c..44f32f0 100644
--- a/include/UECS/detail/ArchetypeCmptTraits.h
+++ b/include/UECS/detail/ArchetypeCmptTraits.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../CmptType.h"
+#include "../AccessTypeID.h"
 #include "../RTDCmptTraits.h"
 
 #include <unordered_map>
@@ -10,31 +10,31 @@ namespace Ubpa::UECS {
 	// run-time static component traits
 	class ArchetypeCmptTraits {
 	public:
-		size_t Sizeof(CmptType) const;
-		size_t Alignof(CmptType) const;
-		void CopyConstruct(CmptType, void* dst, void* src) const;
-		void MoveConstruct(CmptType, void* dst, void* src) const;
-		void MoveAssign(CmptType, void* dst, void* src) const;
-		void Destruct(CmptType, void* cmpt) const;
+		std::size_t Sizeof(TypeID) const;
+		std::size_t Alignof(TypeID) const;
+		void CopyConstruct(TypeID, void* dst, void* src) const;
+		void MoveConstruct(TypeID, void* dst, void* src) const;
+		void MoveAssign(TypeID, void* dst, void* src) const;
+		void Destruct(TypeID, void* cmpt) const;
 
 		template<typename Cmpt>
 		void Register();
 
-		void Register(const RTDCmptTraits&, CmptType);
+		void Register(const RTDCmptTraits&, TypeID);
 
 		template<typename Cmpt>
 		void Deregister() noexcept;
-		void Deregister(CmptType) noexcept;
+		void Deregister(TypeID) noexcept;
 
 	private:
 		friend class Archetype;
 
-		std::unordered_map<CmptType, size_t> sizeofs;
-		std::unordered_map<CmptType, size_t> alignments;
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> copy_constructors; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> move_constructors; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*,void*)>> move_assignments; // dst <- src
-		std::unordered_map<CmptType, std::function<void(void*)>> destructors;
+		std::unordered_map<TypeID, std::size_t> sizeofs;
+		std::unordered_map<TypeID, std::size_t> alignments;
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> copy_constructors; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> move_constructors; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*,void*)>> move_assignments; // dst <- src
+		std::unordered_map<TypeID, std::function<void(void*)>> destructors;
 	};
 }
 
diff --git a/include/UECS/detail/ArchetypeCmptTraits.inl b/include/UECS/detail/ArchetypeCmptTraits.inl
index f669083..56d65a7 100644
--- a/include/UECS/detail/ArchetypeCmptTraits.inl
+++ b/include/UECS/detail/ArchetypeCmptTraits.inl
@@ -3,18 +3,18 @@
 #include <stdexcept>
 
 namespace Ubpa::UECS {
-	inline size_t ArchetypeCmptTraits::Sizeof(CmptType type) const {
+	inline std::size_t ArchetypeCmptTraits::Sizeof(TypeID type) const {
 		auto target = sizeofs.find(type);
 		assert(target != sizeofs.end());
 		return target->second;
 	}
 
-	inline size_t ArchetypeCmptTraits::Alignof(CmptType type) const {
+	inline std::size_t ArchetypeCmptTraits::Alignof(TypeID type) const {
 		auto target = alignments.find(type);
 		return target != alignments.end() ? target->second : RTDCmptTraits::DefaultAlignment();
 	}
 
-	inline void ArchetypeCmptTraits::CopyConstruct(CmptType type, void* dst, void* src) const {
+	inline void ArchetypeCmptTraits::CopyConstruct(TypeID type, void* dst, void* src) const {
 		auto target = copy_constructors.find(type);
 
 		if (target != copy_constructors.end())
@@ -23,7 +23,7 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void ArchetypeCmptTraits::MoveConstruct(CmptType type, void* dst, void* src) const {
+	inline void ArchetypeCmptTraits::MoveConstruct(TypeID type, void* dst, void* src) const {
 		auto target = move_constructors.find(type);
 
 		if (target != move_constructors.end())
@@ -32,7 +32,7 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void ArchetypeCmptTraits::MoveAssign(CmptType type, void* dst, void* src) const {
+	inline void ArchetypeCmptTraits::MoveAssign(TypeID type, void* dst, void* src) const {
 		auto target = move_assignments.find(type);
 
 		if (target != move_assignments.end())
@@ -41,7 +41,7 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void ArchetypeCmptTraits::Destruct(CmptType type, void* cmpt) const {
+	inline void ArchetypeCmptTraits::Destruct(TypeID type, void* cmpt) const {
 		auto target = destructors.find(type);
 		if (target != destructors.end())
 			target->second(cmpt);
@@ -56,7 +56,7 @@ namespace Ubpa::UECS {
 		static_assert(std::is_move_assignable_v<Cmpt>, "<Cmpt> must be move-assignable");
 		static_assert(std::is_destructible_v<Cmpt>, "<Cmpt> must be destructible");
 
-		constexpr CmptType type = CmptType::Of<Cmpt>;
+		constexpr TypeID type = TypeID_of<Cmpt>;
 
 		sizeofs.emplace(type, sizeof(Cmpt));
 		alignments.emplace(type, alignof(Cmpt));
@@ -83,10 +83,10 @@ namespace Ubpa::UECS {
 		}
 	}
 
-	inline void ArchetypeCmptTraits::Register(const RTDCmptTraits& rtdct, CmptType type) {
+	inline void ArchetypeCmptTraits::Register(const RTDCmptTraits& rtdct, TypeID type) {
 		auto size_target = rtdct.GetSizeofs().find(type);
 		if (size_target == rtdct.GetSizeofs().end())
-			throw std::logic_error("ArchetypeCmptTraits::Register: RTDCmptTraits hasn't registered <CmptType>");
+			throw std::logic_error("ArchetypeCmptTraits::Register: RTDCmptTraits hasn't registered <TypeID>");
 		sizeofs[type] = size_target->second;
 		
 		auto alignment_target = rtdct.GetAlignments().find(type);
@@ -110,7 +110,7 @@ namespace Ubpa::UECS {
 
 	template<typename Cmpt>
 	void ArchetypeCmptTraits::Deregister() noexcept {
-		constexpr CmptType type = CmptType::Of<Cmpt>;
+		constexpr TypeID type = TypeID_of<Cmpt>;
 
 		sizeofs.erase(type);
 		alignments.erase(type);
@@ -125,7 +125,7 @@ namespace Ubpa::UECS {
 			move_assignments.erase(type);
 	}
 
-	inline void ArchetypeCmptTraits::Deregister(CmptType type) noexcept {
+	inline void ArchetypeCmptTraits::Deregister(TypeID type) noexcept {
 		sizeofs.erase(type);
 		alignments.erase(type);
 		copy_constructors.erase(type);
diff --git a/include/UECS/detail/Chunk.h b/include/UECS/detail/Chunk.h
index 47c01ae..ba40bdc 100644
--- a/include/UECS/detail/Chunk.h
+++ b/include/UECS/detail/Chunk.h
@@ -10,13 +10,13 @@ namespace Ubpa::UECS {
 	using byte = uint8_t;
 	static_assert(sizeof(byte) == 1);
 	struct alignas(CHUNK_ALIGNMENT) Chunk {
-		static constexpr size_t size = CHUNK_SIZE;
+		static constexpr std::size_t size = CHUNK_SIZE;
 
 		struct Layout {
-			size_t capacity;
-			std::vector<size_t> offsets;
+			std::size_t capacity;
+			std::vector<std::size_t> offsets;
 		};
-		static Layout GenLayout(const std::vector<size_t>& alignments, const std::vector<size_t>& sizes) noexcept;
+		static Layout GenLayout(const std::vector<std::size_t>& alignments, const std::vector<std::size_t>& sizes) noexcept;
 
 		byte* Data() noexcept { return buffer.data(); }
 
diff --git a/include/UECS/detail/ChunkView.inl b/include/UECS/detail/ChunkView.inl
index 7093819..e0a5e5b 100644
--- a/include/UECS/detail/ChunkView.inl
+++ b/include/UECS/detail/ChunkView.inl
@@ -2,15 +2,15 @@
 
 namespace Ubpa::UECS {
 	template<typename Cmpt>
-	Span<Cmpt> ChunkView::GetCmptArray() const {
-		auto* ptr = GetCmptArray(CmptType::Of<Cmpt>);
+	std::span<Cmpt> ChunkView::GetCmptArray() const {
+		auto* ptr = GetCmptArray(TypeID_of<Cmpt>);
 		if (!ptr)
 			return {};
 		return { static_cast<Cmpt*>(ptr), EntityNum() };
 	}
 
-	inline Span<const Entity> ChunkView::GetEntityArray() const {
-		auto* ptr = GetCmptArray(CmptType::Of<Entity>);
+	inline std::span<const Entity> ChunkView::GetEntityArray() const {
+		auto* ptr = GetCmptArray(TypeID_of<Entity>);
 		if (!ptr)
 			return {};
 		return { static_cast<const Entity*>(ptr), EntityNum() };
diff --git a/include/UECS/detail/CmptTag.inl b/include/UECS/detail/CmptTag.inl
index 6951524..215b605 100644
--- a/include/UECS/detail/CmptTag.inl
+++ b/include/UECS/detail/CmptTag.inl
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <UTemplate/Basic.h>
+#include <UTemplate/Util.h>
 
 namespace Ubpa::UECS {
 	class Entity;
@@ -100,7 +100,7 @@ namespace Ubpa::UECS {
 	static constexpr bool IsTaggedCmpt_v = IsTaggedCmpt<T>::value;
 
 	template<typename T, AccessMode defaultMode>
-	static constexpr AccessMode AccessModeOf_default =
+	static constexpr AccessMode AccessMode_of_default =
 		IsLastFrame_v<T> || IsLastFrameSingleton_v<T> ? AccessMode::LAST_FRAME : (
 			IsWrite_v<T> || IsWriteSingleton_v<T> ? AccessMode::WRITE : (
 				IsLatest_v<T> || IsLatestSingleton_v<T> ? AccessMode::LATEST :
@@ -109,68 +109,68 @@ namespace Ubpa::UECS {
 		);
 
 	template<typename T>
-	static constexpr AccessMode AccessModeOf = AccessModeOf_default<T, AccessMode::WRITE>;
+	static constexpr AccessMode AccessMode_of = AccessMode_of_default<T, AccessMode::WRITE>;
 
-	template<typename Cmpt> struct RemoveTag : IType<Cmpt> {}; // default
+	template<typename Cmpt> struct RemoveTag : std::type_identity<Cmpt> {}; // default
 
-	template<typename Cmpt> struct RemoveTag<LastFrame<Cmpt>> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<Write<Cmpt>> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<Latest<Cmpt>> : IType<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<LastFrame<Cmpt>> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Write<Cmpt>> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Latest<Cmpt>> : std::type_identity<Cmpt> {};
 
-	template<typename Cmpt> struct RemoveTag<LastFrame<Singleton<Cmpt>>> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<Write<Singleton<Cmpt>>> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<Latest<Singleton<Cmpt>>> : IType<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<LastFrame<Singleton<Cmpt>>> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Write<Singleton<Cmpt>>> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Latest<Singleton<Cmpt>>> : std::type_identity<Cmpt> {};
 
-	template<typename Cmpt> struct RemoveTag<Cmpt*> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<const Cmpt*> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<Singleton<Cmpt>> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveTag<const Singleton<Cmpt>> : IType<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Cmpt*> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<const Cmpt*> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<Singleton<Cmpt>> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveTag<const Singleton<Cmpt>> : std::type_identity<Cmpt> {};
 
 	// ====
 
-	template<typename T> struct RemoveRWTag : IType<T> {}; // default
+	template<typename T> struct RemoveRWTag : std::type_identity<T> {}; // default
 
-	template<typename T> struct RemoveRWTag<LastFrame<T>> : IType<T> {};
-	template<typename T> struct RemoveRWTag<Write<T>> : IType<T> {};
-	template<typename T> struct RemoveRWTag<Latest<T>> : IType<T> {};
+	template<typename T> struct RemoveRWTag<LastFrame<T>> : std::type_identity<T> {};
+	template<typename T> struct RemoveRWTag<Write<T>> : std::type_identity<T> {};
+	template<typename T> struct RemoveRWTag<Latest<T>> : std::type_identity<T> {};
 
-	template<typename Cmpt> struct RemoveRWTag<Cmpt*> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveRWTag<const Cmpt*> : IType<Cmpt> {};
-	template<typename Cmpt> struct RemoveRWTag<const Singleton<Cmpt>> : IType<Singleton<Cmpt>> {};
+	template<typename Cmpt> struct RemoveRWTag<Cmpt*> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveRWTag<const Cmpt*> : std::type_identity<Cmpt> {};
+	template<typename Cmpt> struct RemoveRWTag<const Singleton<Cmpt>> : std::type_identity<Singleton<Cmpt>> {};
 
 	// ====
 
-	template<typename T> struct RemoveSingletonTag : IType<T> {}; // default
+	template<typename T> struct RemoveSingletonTag : std::type_identity<T> {}; // default
 
-	template<typename Cmpt> struct RemoveSingletonTag<LastFrame<Singleton<Cmpt>>> : IType<LastFrame<Cmpt>> {};
-	template<typename Cmpt> struct RemoveSingletonTag<Write<Singleton<Cmpt>>> : IType<Write<Cmpt>> {};
-	template<typename Cmpt> struct RemoveSingletonTag<Latest<Singleton<Cmpt>>> : IType<Latest<Cmpt>> {};
+	template<typename Cmpt> struct RemoveSingletonTag<LastFrame<Singleton<Cmpt>>> : std::type_identity<LastFrame<Cmpt>> {};
+	template<typename Cmpt> struct RemoveSingletonTag<Write<Singleton<Cmpt>>> : std::type_identity<Write<Cmpt>> {};
+	template<typename Cmpt> struct RemoveSingletonTag<Latest<Singleton<Cmpt>>> : std::type_identity<Latest<Cmpt>> {};
 
-	template<typename Cmpt> struct RemoveSingletonTag<Singleton<Cmpt>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct RemoveSingletonTag<const Singleton<Cmpt>> : IType<const Cmpt*> {};
+	template<typename Cmpt> struct RemoveSingletonTag<Singleton<Cmpt>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct RemoveSingletonTag<const Singleton<Cmpt>> : std::type_identity<const Cmpt*> {};
 
 	// ====
 
-	template<typename T> struct DecayTag : IType<T> {};
+	template<typename T> struct DecayTag : std::type_identity<T> {};
 
-	template<typename Cmpt> struct DecayTag<LastFrame<Cmpt>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<Write<Cmpt>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<Latest<Cmpt>> : IType<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<LastFrame<Cmpt>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<Write<Cmpt>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<Latest<Cmpt>> : std::type_identity<Cmpt*> {};
 
-	template<typename Cmpt> struct DecayTag<LastFrame<Singleton<Cmpt>>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<Write<Singleton<Cmpt>>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<Latest<Singleton<Cmpt>>> : IType<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<LastFrame<Singleton<Cmpt>>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<Write<Singleton<Cmpt>>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<Latest<Singleton<Cmpt>>> : std::type_identity<Cmpt*> {};
 
-	template<typename Cmpt> struct DecayTag<const Cmpt*> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<Singleton<Cmpt>> : IType<Cmpt*> {};
-	template<typename Cmpt> struct DecayTag<const Singleton<Cmpt>> : IType<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<const Cmpt*> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<Singleton<Cmpt>> : std::type_identity<Cmpt*> {};
+	template<typename Cmpt> struct DecayTag<const Singleton<Cmpt>> : std::type_identity<Cmpt*> {};
 
 	// ====
 	
 	template<typename Arg>
 	struct DecayArg : DecayTag<Arg> {};
 	template<>
-	struct DecayArg<const World*> : IType<World*> {};
+	struct DecayArg<const World*> : std::type_identity<World*> {};
 
 	// ====
 
diff --git a/include/UECS/detail/CmptType.inl b/include/UECS/detail/CmptType.inl
deleted file mode 100644
index 4607c4c..0000000
--- a/include/UECS/detail/CmptType.inl
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-namespace std {
-	template<typename T>
-	struct hash;
-}
-
-template<>
-struct std::hash<Ubpa::UECS::CmptType> {
-	constexpr size_t operator()(const Ubpa::UECS::CmptType& t) const noexcept {
-		return t.HashCode();
-	}
-};
-
-template<>
-struct std::hash<Ubpa::UECS::CmptAccessType> {
-	constexpr size_t operator()(const Ubpa::UECS::CmptAccessType& t) const noexcept {
-		return t.HashCode();
-	}
-};
\ No newline at end of file
diff --git a/include/UECS/detail/CmptTypeSet.h b/include/UECS/detail/CmptTypeSet.h
deleted file mode 100644
index de8efb2..0000000
--- a/include/UECS/detail/CmptTypeSet.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma	once
-
-#include "../EntityQuery.h"
-
-#include <UContainer/Span.h>
-
-#include <set>
-
-namespace Ubpa::UECS {
-	struct CmptTypeSet {
-		std::set<CmptType> data;
-
-		size_t HashCode() const noexcept;
-
-		void Insert(Span<const CmptType> types);
-		void Erase(Span<const CmptType> types) noexcept;
-		bool Contains(CmptType type) const;
-
-		bool ContainsAll(Span<const CmptType> types) const;
-		template<typename CmptTypeContainer>
-		bool ContainsAll(const CmptTypeContainer& types) const;
-
-		bool ContainsAny(Span<const CmptType> types) const;
-		template<typename CmptTypeContainer>
-		bool ContainsAny(const CmptTypeContainer& types) const;
-
-		template<typename CmptTypeContainer>
-		bool NotContain(const CmptTypeContainer& types) const;
-
-		bool IsMatch(const ArchetypeFilter& filter) const;
-
-		bool IsMatch(const CmptLocator& locator) const;
-
-		bool IsMatch(const EntityQuery& query) const;
-
-		bool operator==(const CmptTypeSet& rhs) const noexcept { return data == rhs.data; }
-	};
-}
-
-#include "CmptTypeSet.inl"
diff --git a/include/UECS/detail/CmptTypeSet.inl b/include/UECS/detail/CmptTypeSet.inl
deleted file mode 100644
index 48e3a18..0000000
--- a/include/UECS/detail/CmptTypeSet.inl
+++ /dev/null
@@ -1,98 +0,0 @@
-#pragma once
-
-namespace Ubpa::UECS {
-	inline void CmptTypeSet::Insert(Span<const CmptType> types) {
-		for(const auto& type : types)
-			data.insert(type);
-	}
-
-	inline void CmptTypeSet::Erase(Span<const CmptType> types) noexcept {
-		for (const auto& type : types)
-			data.erase(type);
-	}
-
-	inline bool CmptTypeSet::Contains(CmptType type) const {
-		return data.find(type) != data.end();
-	}
-
-	inline bool CmptTypeSet::ContainsAll(Span<const CmptType> types) const {
-		for (const auto& type : types) {
-			if (!Contains(type))
-				return false;
-		}
-		return true;
-	}
-
-	template<typename CmptTypeContainer>
-	bool CmptTypeSet::ContainsAll(const CmptTypeContainer& types) const {
-		for (const auto& type : types) {
-			if (!Contains(type))
-				return false;
-		}
-		return true;
-	}
-
-	inline bool CmptTypeSet::ContainsAny(Span<const CmptType> types) const {
-		for (const auto& type : types) {
-			if (Contains(type))
-				return true;
-		}
-		return false;
-	}
-
-	template<typename CmptTypeContainer>
-	bool CmptTypeSet::ContainsAny(const CmptTypeContainer& types) const {
-		if (types.empty())
-			return true;
-
-		for (const auto& type : types) {
-			if (Contains(type))
-				return true;
-		}
-
-		return false;
-	}
-
-	template<typename CmptTypeContainer>
-	bool CmptTypeSet::NotContain(const CmptTypeContainer& types) const {
-		for (const auto& type : types) {
-			if (Contains(type))
-				return false;
-		}
-		return true;
-	}
-
-	inline bool CmptTypeSet::IsMatch(const ArchetypeFilter& filter) const {
-		return ContainsAll(filter.all)
-			&& ContainsAny(filter.any)
-			&& NotContain(filter.none);
-	}
-
-	inline bool CmptTypeSet::IsMatch(const CmptLocator& locator) const {
-		for (const auto& t : locator.CmptAccessTypes()) {
-			if (!Contains(t))
-				return false;
-		}
-		return true;
-	}
-
-	inline bool CmptTypeSet::IsMatch(const EntityQuery& query) const {
-		return IsMatch(query.filter) && IsMatch(query.locator);
-	}
-
-	inline size_t CmptTypeSet::HashCode() const noexcept {
-		size_t seed = TypeID<CmptTypeSet>;
-		for (const auto& t : data)
-			seed = hash_combine(seed, t.HashCode());
-		return seed;
-	}
-}
-
-namespace std {
-	template<>
-	struct hash<Ubpa::UECS::CmptTypeSet> {
-		size_t operator()(const Ubpa::UECS::CmptTypeSet& types) const noexcept {
-			return types.HashCode();
-		}
-	};
-}
diff --git a/include/UECS/detail/CmptsLocator.inl b/include/UECS/detail/CmptsLocator.inl
index 85b31a9..6808d95 100644
--- a/include/UECS/detail/CmptsLocator.inl
+++ b/include/UECS/detail/CmptsLocator.inl
@@ -1,13 +1,12 @@
 #pragma once
 
 #include <UTemplate/Func.h>
-#include <UContainer/Algorithm.h>
 
 namespace Ubpa::UECS::detail {
 	template<typename... Cmpts>
 	CmptLocator GenerateCmptLocator(TypeList<Cmpts...>) {
 		if constexpr (sizeof...(Cmpts) > 0) {
-			constexpr std::array types{ CmptAccessType::Of<Cmpts>... };
+			constexpr std::array types{ AccessTypeID_of<Cmpts>... };
 			return CmptLocator{ types };
 		}
 		else
@@ -26,8 +25,9 @@ namespace Ubpa::UECS {
 	template<typename Func>
 	CmptLocator& CmptLocator::Combine() {
 		CmptLocator funcLocator = Generate<Func>();
-		cmptTypes = SetUnion(cmptTypes, funcLocator.cmptTypes);
-		UpdateHashCode();
+		for (const auto& type : funcLocator.cmptTypes)
+			cmptTypes.insert(type);
+		UpdateGetValue();
 		return *this;
 	}
 }
diff --git a/include/UECS/detail/EntityMngr.inl b/include/UECS/detail/EntityMngr.inl
index 1a0944f..469c589 100644
--- a/include/UECS/detail/EntityMngr.inl
+++ b/include/UECS/detail/EntityMngr.inl
@@ -8,15 +8,15 @@
 namespace Ubpa::UECS {
 	template<typename... Cmpts>
 	Archetype* EntityMngr::GetOrCreateArchetypeOf() {
-		const auto typeset = Archetype::GenCmptTypeSet<Cmpts...>();
+		const auto typeset = Archetype::GenTypeIDSet<Cmpts...>();
 		auto target = ts2a.find(typeset);
 		if(target != ts2a.end())
 			return target->second.get();
 
-		auto archetype = new Archetype(sharedChunkPool.get(), TypeList<Cmpts...>{});
+		auto archetype = new Archetype(std::pmr::polymorphic_allocator<Chunk>{rsrc.get()}, TypeList<Cmpts...>{});
 		ts2a.emplace(std::move(typeset), std::unique_ptr<Archetype>{ archetype });
 		for (auto& [query, archetypes] : queryCache) {
-			if (archetype->GetCmptTypeSet().IsMatch(query))
+			if (archetype->GetTypeIDSet().IsMatch(query))
 				archetypes.insert(archetype);
 		}
 
@@ -26,7 +26,7 @@ namespace Ubpa::UECS {
 	template<typename... Cmpts>
 	std::tuple<Entity, Cmpts*...> EntityMngr::Create() {
 		Archetype* archetype = GetOrCreateArchetypeOf<Cmpts...>();
-		size_t entityIndex = RequestEntityFreeEntry();
+		std::size_t entityIndex = RequestEntityFreeEntry();
 		EntityInfo& info = entityTable[entityIndex];
 		Entity e{ entityIndex, info.version };
 		info.archetype = archetype;
@@ -42,21 +42,21 @@ namespace Ubpa::UECS {
 		auto& info = entityTable[e.Idx()];
 		Archetype* srcArchetype = info.archetype;
 
-		const auto& srcCmptTypeSet = srcArchetype->GetCmptTypeSet();
-		auto dstCmptTypeSet = srcCmptTypeSet;
-		(dstCmptTypeSet.data.insert(CmptType::Of<Cmpts>), ...);
+		const auto& srcTypeIDSet = srcArchetype->GetTypeIDSet();
+		auto dstTypeIDSet = srcTypeIDSet;
+		(dstTypeIDSet.data.insert(TypeID_of<Cmpts>), ...);
 
 		// get dstArchetype
 		Archetype* dstArchetype;
-		auto target = ts2a.find(dstCmptTypeSet);
+		auto target = ts2a.find(dstTypeIDSet);
 		if (target == ts2a.end()) {
 			dstArchetype = Archetype::Add<Cmpts...>(srcArchetype);
-			assert(dstCmptTypeSet == dstArchetype->GetCmptTypeSet());
+			assert(dstTypeIDSet == dstArchetype->GetTypeIDSet());
 			for (auto& [query, archetypes] : queryCache) {
-				if (dstCmptTypeSet.IsMatch(query))
+				if (dstTypeIDSet.IsMatch(query))
 					archetypes.insert(dstArchetype);
 			}
-			ts2a.emplace(std::move(dstCmptTypeSet), std::unique_ptr<Archetype>{ dstArchetype });
+			ts2a.emplace(std::move(dstTypeIDSet), std::unique_ptr<Archetype>{ dstArchetype });
 		}
 		else {
 			dstArchetype = target->second.get();
@@ -65,11 +65,11 @@ namespace Ubpa::UECS {
 		}
 
 		// move src to dst
-		size_t srcIdxInArchetype = info.idxInArchetype;
-		size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
+		std::size_t srcIdxInArchetype = info.idxInArchetype;
+		std::size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
 
 		auto srcCmptTraits = srcArchetype->GetArchetypeCmptTraits();
-		for (const auto& type : srcCmptTypeSet.data) {
+		for (const auto& type : srcTypeIDSet.data) {
 			auto srcCmpt = srcArchetype->At(type, srcIdxInArchetype);
 			auto dstCmpt = dstArchetype->At(type, dstIdxInArchetype);
 			srcCmptTraits.MoveConstruct(type, dstCmpt, srcCmpt);
@@ -77,7 +77,7 @@ namespace Ubpa::UECS {
 
 		// erase
 		auto srcMovedEntityIndex = srcArchetype->Erase(srcIdxInArchetype);
-		if (srcMovedEntityIndex != static_cast<size_t>(-1))
+		if (srcMovedEntityIndex != static_cast<std::size_t>(-1))
 			entityTable[srcMovedEntityIndex].idxInArchetype = srcIdxInArchetype;
 
 		info.archetype = dstArchetype;
@@ -90,8 +90,8 @@ namespace Ubpa::UECS {
 	std::tuple<Cmpts*...> EntityMngr::Attach(Entity e) {
 		using CmptList = TypeList<Cmpts...>;
 		auto origArchetype = AttachWithoutInit<Cmpts...>(e);
-		const auto& cmptTypes = origArchetype->GetCmptTypeSet();
-		std::array needAttach = { !cmptTypes.Contains(CmptType::Of<Cmpts>)... };
+		const auto& cmptTypes = origArchetype->GetTypeIDSet();
+		std::array needAttach = { !cmptTypes.Contains(TypeID_of<Cmpts>)... };
 		const auto& new_info = entityTable[e.Idx()];
 		std::tuple cmpts{ new_info.archetype->At<Cmpts>(new_info.idxInArchetype)... };
 		((std::get<Find_v<CmptList, Cmpts>>(needAttach) ? new(std::get<Cmpts*>(cmpts))Cmpts : nullptr), ...);
@@ -101,13 +101,13 @@ namespace Ubpa::UECS {
 
 	template<typename... Cmpts>
 	void EntityMngr::Detach(Entity e) {
-		constexpr std::array types{ CmptType::Of<Cmpts>... };
+		constexpr std::array types{ TypeID_of<Cmpts>... };
 		Detach(e, types);
 	}
 
 	template<typename Cmpt>
 	bool EntityMngr::Have(Entity e) const {
-		return Have(e, CmptType::Of<Cmpt>);
+		return Have(e, TypeID_of<Cmpt>);
 	}
 
 	template<typename Cmpt, typename... Args>
@@ -116,24 +116,24 @@ namespace Ubpa::UECS {
 			|| is_list_initializable_v<Cmpt, Args...>,
 			"<Cmpt> isn't constructible/list_initializable with Args...");
 
-		assert(!Have(e, CmptType::Of<Cmpt>));
+		assert(!Have(e, TypeID_of<Cmpt>));
 		AttachWithoutInit<Cmpt>(e);
 		return new(Get<Cmpt>(e))Cmpt{ std::forward<Args>(args)... };
 	}
 
-	inline bool EntityMngr::Have(Entity e, CmptType type) const {
+	inline bool EntityMngr::Have(Entity e, TypeID type) const {
 		assert(!type.Is<Entity>());
 		if (!Exist(e)) throw std::invalid_argument("EntityMngr::Have: Entity is invalid");
-		return entityTable[e.Idx()].archetype->GetCmptTypeSet().Contains(type);
+		return entityTable[e.Idx()].archetype->GetTypeIDSet().Contains(type);
 	}
 
 	template<typename Cmpt>
 	Cmpt* EntityMngr::Get(Entity e) const {
 		static_assert(!std::is_same_v<Cmpt, Entity>, "EntityMngr::Get: <Cmpt> != Entity");
-		return reinterpret_cast<Cmpt*>(Get(e, CmptType::Of<Cmpt>).Ptr());
+		return reinterpret_cast<Cmpt*>(Get(e, TypeID_of<Cmpt>).Ptr());
 	}
 
-	inline CmptPtr EntityMngr::Get(Entity e, CmptType type) const {
+	inline CmptPtr EntityMngr::Get(Entity e, TypeID type) const {
 		assert(!type.Is<Entity>());
 		if (!Exist(e)) throw std::invalid_argument("EntityMngr::Get: Entity is invalid");
 		const auto& info = entityTable[e.Idx()];
@@ -146,30 +146,30 @@ namespace Ubpa::UECS {
 
 	template<typename Cmpt>
 	std::vector<Cmpt*> EntityMngr::GetCmptArray(const ArchetypeFilter& filter) const {
-		constexpr auto type = CmptType::Of<Cmpt>;
+		constexpr auto type = TypeID_of<Cmpt>;
 		assert(filter.all.find(type) != filter.all.end()); // transparent less
 
 		std::vector<Cmpt*> rst;
 
 		const auto& archetypes = QueryArchetypes(filter);
-		size_t num = 0;
+		std::size_t num = 0;
 		for (const auto& archetype : archetypes)
 			num += archetype->EntityNum();
 
 		rst.resize(num);
-		size_t idx = 0;
+		std::size_t idx = 0;
 		for (auto archetype : archetypes) {
-			/*for (size_t i = 0; i < archetype->EntityNum(); i++)
-				rst[idx++] = archetype->At<CmptType>(i);*/
+			/*for (std::size_t i = 0; i < archetype->EntityNum(); i++)
+				rst[idx++] = archetype->At<TypeID>(i);*/
 
 			// speed up
 
-			size_t offset = archetype->Offsetof(type);
-			for (size_t c = 0; c < archetype->chunks.size(); c++) {
+			std::size_t offset = archetype->Offsetof(type);
+			for (std::size_t c = 0; c < archetype->chunks.size(); c++) {
 				auto buffer = archetype->chunks[c]->Data();
 				auto beg = buffer + offset;
-				size_t chunkSize = archetype->EntityNumOfChunk(c);
-				for (size_t i = 0; i < chunkSize; i++)
+				std::size_t chunkSize = archetype->EntityNumOfChunk(c);
+				for (std::size_t i = 0; i < chunkSize; i++)
 					rst[idx++] = reinterpret_cast<Cmpt*>(beg + i * sizeof(Cmpt));
 			}
 		}
diff --git a/include/UECS/detail/EntityQuery.inl b/include/UECS/detail/EntityQuery.inl
index 97d64f7..d0835df 100644
--- a/include/UECS/detail/EntityQuery.inl
+++ b/include/UECS/detail/EntityQuery.inl
@@ -5,8 +5,8 @@ namespace std {
 	struct hash;
 	template<>
 	struct hash<Ubpa::UECS::EntityQuery> {
-		size_t operator()(const Ubpa::UECS::EntityQuery& query) const noexcept {
-			return query.HashCode();
+		std::size_t operator()(const Ubpa::UECS::EntityQuery& query) const noexcept {
+			return query.GetValue();
 		}
 	};
 }
diff --git a/include/UECS/detail/RTDCmptTraits.inl b/include/UECS/detail/RTDCmptTraits.inl
index da4248a..a880988 100644
--- a/include/UECS/detail/RTDCmptTraits.inl
+++ b/include/UECS/detail/RTDCmptTraits.inl
@@ -3,66 +3,66 @@
 #include "../RTDCmptTraits.h"
 
 namespace Ubpa::UECS {
-	inline RTDCmptTraits& RTDCmptTraits::RegisterSize(CmptType type, size_t size) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterSize(TypeID type, std::size_t size) {
 		sizeofs.emplace(type, size);
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterAlignment(CmptType type, size_t alignment) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterAlignment(TypeID type, std::size_t alignment) {
 		alignments.emplace(type, alignment);
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterDefaultConstructor(CmptType type, std::function<void(void*)> f) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterDefaultConstructor(TypeID type, std::function<void(void*)> f) {
 		default_constructors.emplace(type, std::move(f));
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterCopyConstructor(CmptType type, std::function<void(void*,void*)> f) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterCopyConstructor(TypeID type, std::function<void(void*,void*)> f) {
 		copy_constructors.emplace(type, std::move(f));
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterMoveConstructor(CmptType type, std::function<void(void*,void*)> f) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterMoveConstructor(TypeID type, std::function<void(void*,void*)> f) {
 		move_constructors.emplace(type, std::move(f));
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterMoveAssignment(CmptType type, std::function<void(void*,void*)> f) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterMoveAssignment(TypeID type, std::function<void(void*,void*)> f) {
 		move_assignments.emplace(type, std::move(f));
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterDestructor(CmptType type, std::function<void(void*)> f) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterDestructor(TypeID type, std::function<void(void*)> f) {
 		destructors.emplace(type, std::move(f));
 		return *this;
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::RegisterName(CmptType type, std::string name) {
+	inline RTDCmptTraits& RTDCmptTraits::RegisterName(TypeID type, std::string name) {
 		names.emplace(type, std::move(name));
 		return *this;
 	}
 
-	inline size_t RTDCmptTraits::Sizeof(CmptType type) const {
+	inline std::size_t RTDCmptTraits::Sizeof(TypeID type) const {
 		auto target = sizeofs.find(type);
 		assert(target != sizeofs.end());
 		return target->second;
 	}
 
-	inline size_t RTDCmptTraits::Alignof(CmptType type) const {
+	inline std::size_t RTDCmptTraits::Alignof(TypeID type) const {
 		auto target = alignments.find(type);
 
 		return target != alignments.end() ? target->second : DefaultAlignment();
 	}
 
-	inline void RTDCmptTraits::DefaultConstruct(CmptType type, void* cmpt) const {
+	inline void RTDCmptTraits::DefaultConstruct(TypeID type, void* cmpt) const {
 		auto target = default_constructors.find(type);
 
 		if (target != default_constructors.end())
 			target->second(cmpt);
 	}
 
-	inline void RTDCmptTraits::CopyConstruct(CmptType type, void* dst, void* src) const {
+	inline void RTDCmptTraits::CopyConstruct(TypeID type, void* dst, void* src) const {
 		auto target = copy_constructors.find(type);
 
 		if (target != copy_constructors.end())
@@ -71,7 +71,7 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void RTDCmptTraits::MoveConstruct(CmptType type, void* dst, void* src) const {
+	inline void RTDCmptTraits::MoveConstruct(TypeID type, void* dst, void* src) const {
 		auto target = move_constructors.find(type);
 
 		if (target != move_constructors.end())
@@ -80,7 +80,7 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void RTDCmptTraits::MoveAssign(CmptType type, void* dst, void* src) const {
+	inline void RTDCmptTraits::MoveAssign(TypeID type, void* dst, void* src) const {
 		auto target = move_assignments.find(type);
 
 		if (target != move_assignments.end())
@@ -89,13 +89,13 @@ namespace Ubpa::UECS {
 			memcpy(dst, src, Sizeof(type));
 	}
 
-	inline void RTDCmptTraits::Destruct(CmptType type, void* cmpt) const {
+	inline void RTDCmptTraits::Destruct(TypeID type, void* cmpt) const {
 		auto target = destructors.find(type);
 		if (target != destructors.end())
 			target->second(cmpt);
 	}
 
-	inline std::string_view RTDCmptTraits::Nameof(CmptType type) const {
+	inline std::string_view RTDCmptTraits::Nameof(TypeID type) const {
 		auto target = names.find(type);
 		if (target != names.end())
 			return target->second;
@@ -118,11 +118,11 @@ namespace Ubpa::UECS {
 		static_assert(std::is_move_assignable_v<Cmpt>, "<Cmpt> must be move-assignable");
 		static_assert(std::is_destructible_v<Cmpt>, "<Cmpt> must be destructible");
 
-		constexpr CmptType type = CmptType::Of<Cmpt>;
+		constexpr TypeID type = TypeID_of<Cmpt>;
 
 		sizeofs.emplace(type, sizeof(Cmpt));
 		alignments.emplace(type, alignof(Cmpt));
-		names.emplace(type, std::string{ nameof::nameof_type<Cmpt>() });
+		names.emplace(type, std::string{ type_name<Cmpt>().View() });
 
 		if constexpr (!std::is_trivially_default_constructible_v<Cmpt>) {
 			default_constructors.emplace(type, [](void* cmpt) {
@@ -153,7 +153,7 @@ namespace Ubpa::UECS {
 
 	template<typename Cmpt>
 	void RTDCmptTraits::Deregister() {
-		constexpr CmptType type = CmptType::Of<Cmpt>;
+		constexpr TypeID type = TypeID_of<Cmpt>;
 
 		sizeofs.erase(type);
 		alignments.erase(type);
@@ -171,7 +171,7 @@ namespace Ubpa::UECS {
 			copy_constructors.erase(type);
 	}
 
-	inline RTDCmptTraits& RTDCmptTraits::Deregister(CmptType type) noexcept {
+	inline RTDCmptTraits& RTDCmptTraits::Deregister(TypeID type) noexcept {
 		names.erase(type);
 		sizeofs.erase(type);
 		alignments.erase(type);
diff --git a/include/UECS/detail/Schedule.inl b/include/UECS/detail/Schedule.inl
index de2039e..2535b36 100644
--- a/include/UECS/detail/Schedule.inl
+++ b/include/UECS/detail/Schedule.inl
@@ -58,13 +58,14 @@ namespace Ubpa::UECS {
 
 	template<typename... Args>
 	const SystemFunc* Schedule::Request(Args&&... args) {
-		SystemFunc* sysFunc = sysFuncPool.Request(std::forward<Args>(args)...);
-		sysFuncs.emplace(sysFunc->HashCode(), sysFunc);
+		SystemFunc* sysFunc = sysFuncAllocator.allocate(1);
+		new(sysFunc)SystemFunc(std::forward<Args>(args)...);
+		sysFuncs.emplace(sysFunc->GetValue(), sysFunc);
 		return sysFunc;
 	}
 
 	inline Schedule& Schedule::LockFilter(std::string_view sys) {
-		sysLockFilter.insert(SystemFunc::HashCode(sys));
+		sysLockFilter.insert(SystemFunc::GetValue(sys));
 		return *this;
 	}
 }
diff --git a/include/UECS/detail/SingletonLocator.inl b/include/UECS/detail/SingletonLocator.inl
index 5a72a90..9107e47 100644
--- a/include/UECS/detail/SingletonLocator.inl
+++ b/include/UECS/detail/SingletonLocator.inl
@@ -1,13 +1,12 @@
 #pragma once
 
 #include <UTemplate/Func.h>
-#include <UContainer/Algorithm.h>
 
 namespace Ubpa::UECS::detail {
 	template<typename... Singletons>
 	SingletonLocator GenerateSingletonLocator(TypeList<Singletons...>) {
 		if constexpr (sizeof...(Singletons) > 0) {
-			constexpr std::array types{ CmptAccessType::Of<Singletons>... };
+			constexpr std::array types{ AccessTypeID_of<Singletons>... };
 			return SingletonLocator{ types };
 		}
 		else
@@ -26,7 +25,8 @@ namespace Ubpa::UECS {
 	template<typename Func>
 	SingletonLocator& SingletonLocator::Combine() {
 		SingletonLocator funcLocator = Generate<Func>();
-		singletonTypes = SetUnion(singletonTypes, funcLocator.singletonTypes);
+		for (const auto& type : funcLocator.singletonTypes)
+			singletonTypes.insert(type);
 		return *this;
 	}
 }
diff --git a/include/UECS/detail/SystemFunc.h b/include/UECS/detail/SystemFunc.h
index 0511d0a..58bfbd1 100644
--- a/include/UECS/detail/SystemFunc.h
+++ b/include/UECS/detail/SystemFunc.h
@@ -20,11 +20,11 @@ namespace Ubpa::UECS {
 	// common arguments : [const] World*, SingletonsView, {LastFrame|Latest}<Singleton<Cmpt>>
 	// 1. Mode::Entity: per entity function
 	// * Entity
-	// * size_t indexInQuery
+	// * std::size_t indexInQuery
 	// * <tagged-components>: {LastFrame|Write|Latest}<Cmpt>...
 	// * CmptsView
 	// 2. Mode::Chunk
-	// * size_t entityBeginIndexInQuery
+	// * std::size_t entityBeginIndexInQuery
 	// * ChunkView (necessary)
 	// 3. Mode::Job
 	// * Write<Singleton<Cmpt>> (only job can write singletons)
@@ -54,12 +54,12 @@ namespace Ubpa::UECS {
 		
 		const std::string& Name() const noexcept { return name; }
 
-		static constexpr size_t HashCode(std::string_view name) noexcept { return hash_string(name); }
+		static constexpr std::size_t GetValue(std::string_view name) noexcept { return string_hash(name); }
 
-		size_t HashCode() const noexcept { return hashCode; }
+		std::size_t GetValue() const noexcept { return hashCode; }
 
-		void operator()(World*, SingletonsView, Entity, size_t entityIndexInQuery, CmptsView) const;
-		void operator()(World*, SingletonsView, size_t entityBeginIndexInQuery, ChunkView) const;
+		void operator()(World*, SingletonsView, Entity, std::size_t entityIndexInQuery, CmptsView) const;
+		void operator()(World*, SingletonsView, std::size_t entityBeginIndexInQuery, ChunkView) const;
 		void operator()(World*, SingletonsView) const;
 
 		Mode GetMode() const noexcept { return mode; }
@@ -69,9 +69,9 @@ namespace Ubpa::UECS {
 	private:
 		Mode mode;
 		std::string name;
-		size_t hashCode; // after name
+		std::size_t hashCode; // after name
 		bool isParallel;
-		std::function<void(World*, SingletonsView, Entity, size_t, CmptsView, ChunkView)> func;
+		std::function<void(World*, SingletonsView, Entity, std::size_t, CmptsView, ChunkView)> func;
 	};
 }
 
diff --git a/include/UECS/detail/SystemFunc.inl b/include/UECS/detail/SystemFunc.inl
index 31de399..d9b4071 100644
--- a/include/UECS/detail/SystemFunc.inl
+++ b/include/UECS/detail/SystemFunc.inl
@@ -24,7 +24,7 @@ namespace Ubpa::UECS {
 		randomAccessor{std::move(randomAccessor)},
 		mode{ Mode::Entity },
 		name{ std::move(name) },
-		hashCode{ HashCode(this->name) },
+		hashCode{ GetValue(this->name) },
 		isParallel{ isParallel },
 		func{ detail::Pack(std::forward<Func>(func)) }
 	{
@@ -54,7 +54,7 @@ namespace Ubpa::UECS {
 		randomAccessor{ std::move(randomAccessor) },
 		mode{ Mode::Chunk },
 		name{ std::move(name) },
-		hashCode{ HashCode(this->name) },
+		hashCode{ GetValue(this->name) },
 		isParallel{ isParallel },
 		func{ detail::Pack(std::forward<Func>(func)) }
 	{
@@ -86,7 +86,7 @@ namespace Ubpa::UECS {
 		randomAccessor {std::move(randomAccessor)},
 		mode{ Mode::Job },
 		name{ std::move(name) },
-		hashCode{ HashCode(this->name) },
+		hashCode{ GetValue(this->name) },
 		isParallel{ false },
 		func{ detail::Pack(std::forward<Func>(func)) }
 	{
@@ -97,7 +97,7 @@ namespace Ubpa::UECS {
 
 		static_assert(
 			!Contain_v<ArgList, Entity>
-			&& !Contain_v<ArgList, size_t>
+			&& !Contain_v<ArgList, std::size_t>
 			&& !Contain_v<ArgList, CmptsView>
 			&& !Contain_v<ArgList, ChunkView>,
 			"(Mode::Job) SystemFunc's argument list cann't have Entity, indexInQuery CmptsView or ChunkView"
@@ -119,7 +119,7 @@ namespace Ubpa::UECS::detail {
 				World* w,
 				SingletonsView singletons,
 				Entity e,
-				size_t entityIndexInQuery,
+				std::size_t entityIndexInQuery,
 				CmptsView cmpts,
 				ChunkView chunkView)
 			{
diff --git a/include/UECS/detail/SystemMngr.inl b/include/UECS/detail/SystemMngr.inl
index 62816ac..76b5bfe 100644
--- a/include/UECS/detail/SystemMngr.inl
+++ b/include/UECS/detail/SystemMngr.inl
@@ -2,8 +2,8 @@
 
 namespace Ubpa::UECS {
 	template<typename... Systems>
-	std::array<size_t, sizeof...(Systems)> SystemMngr::RegisterAndCreate() {
-		std::array<size_t, sizeof...(Systems)> systemIDs = systemTraits.Register<Systems...>();
+	std::array<std::size_t, sizeof...(Systems)> SystemMngr::RegisterAndCreate() {
+		std::array<std::size_t, sizeof...(Systems)> systemIDs = systemTraits.Register<Systems...>();
 		std::apply([this](auto... IDs) {
 			(Create(IDs), ...);
 		}, systemIDs);
@@ -11,8 +11,8 @@ namespace Ubpa::UECS {
 	}
 
 	template<typename... Systems>
-	std::array<size_t, sizeof...(Systems)> SystemMngr::RegisterAndActivate() {
-		std::array<size_t, sizeof...(Systems)> systemIDs = systemTraits.Register<Systems...>();
+	std::array<std::size_t, sizeof...(Systems)> SystemMngr::RegisterAndActivate() {
+		std::array<std::size_t, sizeof...(Systems)> systemIDs = systemTraits.Register<Systems...>();
 		std::apply([this](auto... IDs) {
 			(Activate(IDs), ...);
 		}, systemIDs);
diff --git a/include/UECS/detail/SystemTraits.inl b/include/UECS/detail/SystemTraits.inl
index 0e85bc3..35a6a26 100644
--- a/include/UECS/detail/SystemTraits.inl
+++ b/include/UECS/detail/SystemTraits.inl
@@ -1,33 +1,31 @@
 #pragma once
 
-#include <nameof.hpp>
-
-#include <UTemplate/Concept.h>
+#include <UTemplate/Name.h>
 
 namespace Ubpa::UECS::detail {
 	template<typename System>
-	Concept(HaveOnCreate,     static_cast<SystemTraits::OnCreate*    >(&System::OnCreate    ));
+	concept HaveOnCreate     = requires(World* w) { { System::OnCreate(w) }; };
 	template<typename System>
-	Concept(HaveOnActivate,   static_cast<SystemTraits::OnActivate*  >(&System::OnActivate  ));
+	concept HaveOnActivate   = requires(World * w) { { System::OnActivate(w) }; };
 	template<typename System>
-	Concept(HaveOnUpdate,     static_cast<SystemTraits::OnUpdate*    >(&System::OnUpdate    ));
+	concept HaveOnUpdate     = requires(Schedule& schedule){ { System::OnUpdate(schedule) }; };
 	template<typename System>
-	Concept(HaveOnDeactivate, static_cast<SystemTraits::OnDeactivate*>(&System::OnDeactivate));
+	concept HaveOnDeactivate = requires(World * w) { { System::OnDeactivate(w) }; };
 	template<typename System>
-	Concept(HaveOnDestroy,    static_cast<SystemTraits::OnDestroy*   >(&System::OnDestroy   ));
+	concept HaveOnDestroy    = requires(World * w) { { System::OnDestroy(w) }; };
 	
 	template<typename System>
-	size_t Register(SystemTraits& traits) {
-		size_t ID = traits.Register(std::string{ SystemTraits::StaticNameof<System>() });
-		if constexpr (Require<HaveOnCreate, System>)
-			traits.RegisterOnCreate    (ID, static_cast<SystemTraits::OnCreate*   >(&System::OnCreate     ));
-		if constexpr (Require<HaveOnActivate, System>)
+	std::size_t Register(SystemTraits& traits) {
+		std::size_t ID = traits.Register(std::string{ SystemTraits::StaticNameof<System>() });
+		if constexpr (HaveOnCreate<System>)
+			traits.RegisterOnCreate    (ID, static_cast<SystemTraits::OnCreate*    >(&System::OnCreate     ));
+		if constexpr (HaveOnActivate<System>)
 			traits.RegisterOnActivate  (ID, static_cast<SystemTraits::OnActivate*  >(&System::OnActivate  ));
-		if constexpr (Require<HaveOnUpdate, System>)
+		if constexpr (HaveOnUpdate<System>)
 			traits.RegisterOnUpdate    (ID, static_cast<SystemTraits::OnUpdate*    >(&System::OnUpdate    ));
-		if constexpr (Require<HaveOnDeactivate, System>)
+		if constexpr (HaveOnDeactivate<System>)
 			traits.RegisterOnDeactivate(ID, static_cast<SystemTraits::OnDeactivate*>(&System::OnDeactivate));
-		if constexpr (Require<HaveOnDeactivate, System>)
+		if constexpr (HaveOnDeactivate<System>)
 			traits.RegisterOnDestroy   (ID, static_cast<SystemTraits::OnDestroy*   >(&System::OnDestroy   ));
 		return ID;
 	}
@@ -35,12 +33,12 @@ namespace Ubpa::UECS::detail {
 
 namespace Ubpa::UECS {
 	template<typename... Systems>
-	std::array<size_t, sizeof...(Systems)> SystemTraits::Register() {
+	std::array<std::size_t, sizeof...(Systems)> SystemTraits::Register() {
 		return { detail::Register<Systems>(*this)... };
 	}
 
 	template<typename System>
 	std::string_view SystemTraits::StaticNameof() noexcept {
-		return nameof::nameof_type<System>();
+		return type_name<System>().View();
 	}
 }
diff --git a/include/UECS/detail/TypeIDSet.h b/include/UECS/detail/TypeIDSet.h
new file mode 100644
index 0000000..234d5ea
--- /dev/null
+++ b/include/UECS/detail/TypeIDSet.h
@@ -0,0 +1,40 @@
+#pragma	once
+
+#include "../EntityQuery.h"
+
+#include <span>
+
+#include <set>
+
+namespace Ubpa::UECS {
+	struct TypeIDSet {
+		std::set<TypeID> data;
+
+		std::size_t GetValue() const noexcept;
+
+		void Insert(std::span<const TypeID> types);
+		void Erase(std::span<const TypeID> types) noexcept;
+		bool Contains(TypeID type) const;
+
+		bool ContainsAll(std::span<const TypeID> types) const;
+		template<typename TypeIDContainer>
+		bool ContainsAll(const TypeIDContainer& types) const;
+
+		bool ContainsAny(std::span<const TypeID> types) const;
+		template<typename TypeIDContainer>
+		bool ContainsAny(const TypeIDContainer& types) const;
+
+		template<typename TypeIDContainer>
+		bool NotContain(const TypeIDContainer& types) const;
+
+		bool IsMatch(const ArchetypeFilter& filter) const;
+
+		bool IsMatch(const CmptLocator& locator) const;
+
+		bool IsMatch(const EntityQuery& query) const;
+
+		bool operator==(const TypeIDSet& rhs) const noexcept { return data == rhs.data; }
+	};
+}
+
+#include "TypeIDSet.inl"
diff --git a/include/UECS/detail/TypeIDSet.inl b/include/UECS/detail/TypeIDSet.inl
new file mode 100644
index 0000000..c0e57c1
--- /dev/null
+++ b/include/UECS/detail/TypeIDSet.inl
@@ -0,0 +1,98 @@
+#pragma once
+
+namespace Ubpa::UECS {
+	inline void TypeIDSet::Insert(std::span<const TypeID> types) {
+		for(const auto& type : types)
+			data.insert(type);
+	}
+
+	inline void TypeIDSet::Erase(std::span<const TypeID> types) noexcept {
+		for (const auto& type : types)
+			data.erase(type);
+	}
+
+	inline bool TypeIDSet::Contains(TypeID type) const {
+		return data.find(type) != data.end();
+	}
+
+	inline bool TypeIDSet::ContainsAll(std::span<const TypeID> types) const {
+		for (const auto& type : types) {
+			if (!Contains(type))
+				return false;
+		}
+		return true;
+	}
+
+	template<typename TypeIDContainer>
+	bool TypeIDSet::ContainsAll(const TypeIDContainer& types) const {
+		for (const auto& type : types) {
+			if (!Contains(type))
+				return false;
+		}
+		return true;
+	}
+
+	inline bool TypeIDSet::ContainsAny(std::span<const TypeID> types) const {
+		for (const auto& type : types) {
+			if (Contains(type))
+				return true;
+		}
+		return false;
+	}
+
+	template<typename TypeIDContainer>
+	bool TypeIDSet::ContainsAny(const TypeIDContainer& types) const {
+		if (types.empty())
+			return true;
+
+		for (const auto& type : types) {
+			if (Contains(type))
+				return true;
+		}
+
+		return false;
+	}
+
+	template<typename TypeIDContainer>
+	bool TypeIDSet::NotContain(const TypeIDContainer& types) const {
+		for (const auto& type : types) {
+			if (Contains(type))
+				return false;
+		}
+		return true;
+	}
+
+	inline bool TypeIDSet::IsMatch(const ArchetypeFilter& filter) const {
+		return ContainsAll(filter.all)
+			&& ContainsAny(filter.any)
+			&& NotContain(filter.none);
+	}
+
+	inline bool TypeIDSet::IsMatch(const CmptLocator& locator) const {
+		for (const auto& t : locator.AccessTypeIDs()) {
+			if (!Contains(t))
+				return false;
+		}
+		return true;
+	}
+
+	inline bool TypeIDSet::IsMatch(const EntityQuery& query) const {
+		return IsMatch(query.filter) && IsMatch(query.locator);
+	}
+
+	inline std::size_t TypeIDSet::GetValue() const noexcept {
+		std::size_t seed = TypeID_of<TypeIDSet>.GetValue();
+		for (const auto& t : data)
+			seed = hash_combine(seed, t.GetValue());
+		return seed;
+	}
+}
+
+namespace std {
+	template<>
+	struct hash<Ubpa::UECS::TypeIDSet> {
+		std::size_t operator()(const Ubpa::UECS::TypeIDSet& types) const noexcept {
+			return types.GetValue();
+		}
+	};
+}
diff --git a/include/UECS/detail/Util.h b/include/UECS/detail/Util.h
index 719d12b..2cf6936 100644
--- a/include/UECS/detail/Util.h
+++ b/include/UECS/detail/Util.h
@@ -4,14 +4,11 @@
 #include <string_view>
 
 namespace Ubpa::UECS {
-    constexpr size_t hash_combine(size_t x, size_t y) noexcept;
-    template<size_t N>
-    constexpr size_t hash_combine(const std::array<size_t, N>& arr) noexcept;
+    constexpr std::size_t hash_combine(std::size_t x, std::size_t y) noexcept;
+    template<std::size_t N>
+    constexpr std::size_t hash_combine(const std::array<std::size_t, N>& arr) noexcept;
     template<typename Container>
-    size_t hash_combine(const Container& container) noexcept;
-
-    // fnv1a
-    constexpr size_t hash_string(std::string_view str) noexcept;
+    std::size_t hash_combine(const Container& container) noexcept;
 }
 
 #include "Util.inl"
diff --git a/include/UECS/detail/Util.inl b/include/UECS/detail/Util.inl
index 77fa783..0de3752 100644
--- a/include/UECS/detail/Util.inl
+++ b/include/UECS/detail/Util.inl
@@ -3,25 +3,25 @@
 #include <UTemplate/TypeID.h>
 
 namespace Ubpa::UECS {
-    constexpr size_t hash_combine(size_t x, size_t y) noexcept {
+    constexpr std::size_t hash_combine(std::size_t x, std::size_t y) noexcept {
         return x ^ (y + 0x9e3779b9 + (x << 6) + (x >> 2));
     }
 
-    template<size_t N>
-    constexpr size_t hash_combine(const std::array<size_t, N>& arr) noexcept {
+    template<std::size_t N>
+    constexpr std::size_t hash_combine(const std::array<std::size_t, N>& arr) noexcept {
         static_assert(N >= 2);
-        size_t rst = arr[0];
-        for (size_t i = 1; i < N; i++)
+        std::size_t rst = arr[0];
+        for (std::size_t i = 1; i < N; i++)
             rst = hash_combine(rst, arr[i]);
         return rst;
     }
 
     template<typename Container>
-    size_t hash_combine(const Container& container) noexcept {
-        static_assert(std::is_same_v<typename Container::value_type, size_t>);
+    std::size_t hash_combine(const Container& container) noexcept {
+        static_assert(std::is_same_v<typename Container::value_type, std::size_t>);
         assert(!container.empty());
         auto iter = container.cbegin();
-        size_t rst = *iter;
+        std::size_t rst = *iter;
         ++iter;
         while (iter != container.cend()) {
             rst = hash_combine(rst, *iter);
@@ -29,9 +29,4 @@ namespace Ubpa::UECS {
         }
         return rst;
     }
-
-    // fnv1a
-    constexpr size_t hash_string(std::string_view str) noexcept {
-        return RuntimeTypeID(str);
-    }
 }
diff --git a/include/UECS/detail/World.inl b/include/UECS/detail/World.inl
index 3b332c6..aef5516 100644
--- a/include/UECS/detail/World.inl
+++ b/include/UECS/detail/World.inl
@@ -35,7 +35,7 @@ namespace Ubpa::UECS {
 		static_assert(Length_v<Filter_t<ArgList, IsWrite>> == 0,
 			"const RunEntityJob can't write cmpt");
 		assert("const RunEntityJob can't write cmpt"
-			&& !cmptLocator.HasWriteCmptType());
+			&& !cmptLocator.HasWriteTypeID());
 
 		const_cast<World*>(this)->RunEntityJob(
 			std::forward<Func>(func),
@@ -75,7 +75,7 @@ namespace Ubpa::UECS {
 		static_assert(Contain_v<ArgList, World*> == 0,
 			"const RunChunkJob should use const World*");
 		assert("const RunChunkJob can't write cmpt"
-			&& !filter.HaveWriteCmptType());
+			&& !filter.HaveWriteTypeID());
 
 		const_cast<World*>(this)->RunChunkJob(
 			std::forward<Func>(func),
diff --git a/src/app/CmptHashCode/CMakeLists.txt b/src/app/CmptHashCode/CMakeLists.txt
index 66acc83..236eaff 100644
--- a/src/app/CmptHashCode/CMakeLists.txt
+++ b/src/app/CmptHashCode/CMakeLists.txt
@@ -1,7 +1,7 @@
 Ubpa_GetTargetName(core "${PROJECT_SOURCE_DIR}/src/core")
 Ubpa_AddTarget(
   MODE EXE
-  OUTPUT_NAME CmptHashCodeGenerator
+  OUTPUT_NAME CmptGetValueGenerator
   LIB
     Ubpa::UTemplate_core
   INC_PRIVATE
diff --git a/src/app/CmptHashCode/main.cpp b/src/app/CmptHashCode/main.cpp
index b3bcf38..c5aa61c 100644
--- a/src/app/CmptHashCode/main.cpp
+++ b/src/app/CmptHashCode/main.cpp
@@ -1,4 +1,4 @@
-#include <UECS/CmptType.h>
+#include <UTemplate/TypeID.h>
 
 #include <iostream>
 
@@ -8,7 +8,7 @@ int main(int argc, char** argv) {
 	if (argc != 2)
 		return 1;
 
-	std::cout << Ubpa::UECS::CmptType(argv[1]).HashCode() << std::endl;
+	std::cout << Ubpa::TypeID(argv[1]).GetValue() << std::endl;
 
 	return 0;
 }
diff --git a/src/core/Archetype.cpp b/src/core/Archetype.cpp
index 54bf961..31aba91 100644
--- a/src/core/Archetype.cpp
+++ b/src/core/Archetype.cpp
@@ -9,13 +9,13 @@ Archetype::~Archetype() {
 		if(target == cmptTraits.destructors.end())
 			continue;
 		const auto& destructor = target->second;
-		size_t size = cmptTraits.Sizeof(type);
-		size_t offset = Offsetof(type);
-		for (size_t k = 0; k < chunks.size(); k++) {
-			size_t num = EntityNumOfChunk(k);
+		std::size_t size = cmptTraits.Sizeof(type);
+		std::size_t offset = Offsetof(type);
+		for (std::size_t k = 0; k < chunks.size(); k++) {
+			std::size_t num = EntityNumOfChunk(k);
 			byte* buffer = chunks[k]->Data();
 			byte* beg = buffer + offset;
-			for (size_t i = 0; i < num; i++) {
+			for (std::size_t i = 0; i < num; i++) {
 				byte* address = beg + i * size;
 				destructor(address);
 			}
@@ -26,8 +26,8 @@ Archetype::~Archetype() {
 	//	entityMngr->sharedChunkPool.Recycle(chunk);
 }
 
-Archetype::Archetype(Pool<Chunk>* pool, const Archetype& src)
-	: chunkPool{ pool }
+Archetype::Archetype(std::pmr::polymorphic_allocator<Chunk> chunkAllocator, const Archetype& src)
+	: chunkAllocator{ chunkAllocator }
 {
 	types = src.types;
 	cmptTraits = src.cmptTraits;
@@ -36,10 +36,10 @@ Archetype::Archetype(Pool<Chunk>* pool, const Archetype& src)
 	chunkCapacity = src.chunkCapacity;
 
 	chunks.resize(src.chunks.size(), nullptr);
-	for (size_t i = 0; i < src.chunks.size(); i++) {
+	for (std::size_t i = 0; i < src.chunks.size(); i++) {
 		auto* srcChunk = src.chunks[i];
-		auto* dstChunk = chunks[i] = chunkPool->Request();
-		size_t num = src.EntityNumOfChunk(i);
+		auto* dstChunk = chunks[i] = chunkAllocator.allocate(1);
+		std::size_t num = src.EntityNumOfChunk(i);
 		for (auto type : types.data) {
 			auto offset = Offsetof(type);
 			auto* srcBegin = srcChunk->Data() + offset;
@@ -48,7 +48,7 @@ Archetype::Archetype(Pool<Chunk>* pool, const Archetype& src)
 			auto target = cmptTraits.copy_constructors.find(type);
 			if (target != cmptTraits.copy_constructors.end()) {
 				const auto& copy_ctor = target->second;
-				for (size_t j = 0; j < num; j++) {
+				for (std::size_t j = 0; j < num; j++) {
 					auto offset_j = j * size;
 					copy_ctor(dstBegin + offset_j, srcBegin + offset_j);
 				}
@@ -60,10 +60,10 @@ Archetype::Archetype(Pool<Chunk>* pool, const Archetype& src)
 }
 
 void Archetype::SetLayout() {
-	vector<size_t> alignments;
-	vector<size_t> sizes;
+	vector<std::size_t> alignments;
+	vector<std::size_t> sizes;
 
-	const size_t numType = types.data.size();
+	const std::size_t numType = types.data.size();
 
 	alignments.reserve(numType);
 	sizes.reserve(numType);
@@ -77,17 +77,17 @@ void Archetype::SetLayout() {
 	auto layout = Chunk::GenLayout(alignments, sizes);
 	chunkCapacity = layout.capacity;
 
-	size_t i = 0;
+	std::size_t i = 0;
 	for (const auto& type : types.data)
 		type2offset.emplace(type, layout.offsets[i++]);
 }
 
-Archetype* Archetype::New(RTDCmptTraits& rtdCmptTraits, Pool<Chunk>* chunkPool, Span<const CmptType> types) {
+Archetype* Archetype::New(RTDCmptTraits& rtdCmptTraits, std::pmr::polymorphic_allocator<Chunk> chunkAllocator, std::span<const TypeID> types) {
 	assert(NotContainEntity(types));
 
-	auto* rst = new Archetype{ chunkPool };
+	auto* rst = new Archetype{ chunkAllocator };
 	rst->types.Insert(types);
-	rst->types.data.insert(CmptType::Of<Entity>);
+	rst->types.data.insert(TypeID_of<Entity>);
 	rst->cmptTraits.Register<Entity>();
 	for(const auto& type : types)
 		rst->cmptTraits.Register(rtdCmptTraits, type);
@@ -95,11 +95,11 @@ Archetype* Archetype::New(RTDCmptTraits& rtdCmptTraits, Pool<Chunk>* chunkPool,
 	return rst;
 }
 
-Archetype* Archetype::Add(RTDCmptTraits& rtdCmptTraits, const Archetype* from, Span<const CmptType> types) {
+Archetype* Archetype::Add(RTDCmptTraits& rtdCmptTraits, const Archetype* from, std::span<const TypeID> types) {
 	assert(NotContainEntity(types));
 	assert(!from->types.ContainsAll(types));
 
-	auto* rst = new Archetype{ from->chunkPool };
+	auto* rst = new Archetype{ from->chunkAllocator };
 
 	rst->types = from->types;
 	rst->cmptTraits = from->cmptTraits;
@@ -112,11 +112,11 @@ Archetype* Archetype::Add(RTDCmptTraits& rtdCmptTraits, const Archetype* from, S
 	return rst;
 }
 
-Archetype* Archetype::Remove(const Archetype* from, Span<const CmptType> types) {
+Archetype* Archetype::Remove(const Archetype* from, std::span<const TypeID> types) {
 	assert(NotContainEntity(types));
 	assert(from->types.ContainsAny(types));
 	
-	auto* rst = new Archetype{ from->chunkPool };
+	auto* rst = new Archetype{ from->chunkAllocator };
 
 	rst->types = from->types;
 	rst->cmptTraits = from->cmptTraits;
@@ -129,15 +129,15 @@ Archetype* Archetype::Remove(const Archetype* from, Span<const CmptType> types)
 	return rst;
 }
 
-size_t Archetype::Create(RTDCmptTraits& rtdCmptTraits, Entity e) {
-	size_t idx = RequestBuffer();
-	size_t idxInChunk = idx % chunkCapacity;
+std::size_t Archetype::Create(RTDCmptTraits& rtdCmptTraits, Entity e) {
+	std::size_t idx = RequestBuffer();
+	std::size_t idxInChunk = idx % chunkCapacity;
 	byte* buffer = chunks[idx / chunkCapacity]->Data();
 
 	for (const auto& type : types.data) {
 		if (type.Is<Entity>()) {
-			constexpr size_t size = sizeof(Entity);
-			size_t offset = Offsetof(type);
+			constexpr std::size_t size = sizeof(Entity);
+			std::size_t offset = Offsetof(type);
 			memcpy(buffer + offset + idxInChunk * size, &e, size);
 		}
 		else {
@@ -145,8 +145,8 @@ size_t Archetype::Create(RTDCmptTraits& rtdCmptTraits, Entity e) {
 			if (target == rtdCmptTraits.GetDefaultConstructors().end())
 				continue;
 			const auto& ctor = target->second;
-			size_t size = cmptTraits.Sizeof(type);
-			size_t offset = Offsetof(type);
+			std::size_t size = cmptTraits.Sizeof(type);
+			std::size_t offset = Offsetof(type);
 			byte* dst = buffer + offset + idxInChunk * size;
 			ctor(dst);
 		}
@@ -155,47 +155,47 @@ size_t Archetype::Create(RTDCmptTraits& rtdCmptTraits, Entity e) {
 	return idx;
 }
 
-size_t Archetype::RequestBuffer() {
+std::size_t Archetype::RequestBuffer() {
 	if (entityNum == chunks.size() * chunkCapacity) {
-		auto* chunk = chunkPool->Request();
+		auto* chunk = chunkAllocator.allocate(1);
 		chunks.push_back(chunk);
 	}
 	return entityNum++;
 }
 
-void* Archetype::At(CmptType type, size_t idx) const {
+void* Archetype::At(TypeID type, std::size_t idx) const {
 	assert(idx < entityNum);
 	
 	if (!types.Contains(type))
 		return nullptr;
 	
-	size_t size = cmptTraits.Sizeof(type);
-	size_t offset = Offsetof(type);
-	size_t idxInChunk = idx % chunkCapacity;
+	std::size_t size = cmptTraits.Sizeof(type);
+	std::size_t offset = Offsetof(type);
+	std::size_t idxInChunk = idx % chunkCapacity;
 	byte* buffer = chunks[idx / chunkCapacity]->Data();
 
 	return buffer + offset + idxInChunk * size;
 }
 
-size_t Archetype::Instantiate(Entity e, size_t srcIdx) {
+std::size_t Archetype::Instantiate(Entity e, std::size_t srcIdx) {
 	assert(srcIdx < entityNum);
 
-	size_t dstIdx = RequestBuffer();
+	std::size_t dstIdx = RequestBuffer();
 
-	size_t srcIdxInChunk = srcIdx % chunkCapacity;
-	size_t dstIdxInChunk = dstIdx % chunkCapacity;
+	std::size_t srcIdxInChunk = srcIdx % chunkCapacity;
+	std::size_t dstIdxInChunk = dstIdx % chunkCapacity;
 	byte* srcBuffer = chunks[srcIdx / chunkCapacity]->Data();
 	byte* dstBuffer = chunks[dstIdx / chunkCapacity]->Data();
 
 	for (const auto& type : types.data) {
-		size_t offset = Offsetof(type);
+		std::size_t offset = Offsetof(type);
 
 		if (type.Is<Entity>()) {
-			constexpr size_t size = sizeof(Entity);
+			constexpr std::size_t size = sizeof(Entity);
 			memcpy(dstBuffer + offset + dstIdxInChunk * size, &e, size);
 		}
 		else {
-			size_t size = cmptTraits.Sizeof(type);
+			std::size_t size = cmptTraits.Sizeof(type);
 			byte* dst = dstBuffer + offset + dstIdxInChunk * size;
 			byte* src = srcBuffer + offset + srcIdxInChunk * size;
 
@@ -206,33 +206,33 @@ size_t Archetype::Instantiate(Entity e, size_t srcIdx) {
 	return dstIdx;
 }
 
-tuple<vector<Entity*>, vector<vector<CmptAccessPtr>>, vector<size_t>> Archetype::Locate(const CmptLocator& locator) const {
+tuple<vector<Entity*>, vector<vector<CmptAccessPtr>>, vector<std::size_t>> Archetype::Locate(const CmptLocator& locator) const {
 	assert(types.IsMatch(locator));
 
-	const size_t numChunk = chunks.size();
-	const size_t numType = locator.CmptAccessTypes().size();
-	const size_t offsetEntity = Offsetof(CmptType::Of<Entity>);
+	const std::size_t numChunk = chunks.size();
+	const std::size_t numType = locator.AccessTypeIDs().size();
+	const std::size_t offsetEntity = Offsetof(TypeID_of<Entity>);
 
 	vector<vector<CmptAccessPtr>> chunkCmpts(numChunk);
 	vector<Entity*> chunkEntity(numChunk);
 
-	for (size_t i = 0; i < numChunk; i++) {
+	for (std::size_t i = 0; i < numChunk; i++) {
 		byte* data = chunks[i]->Data();
 		chunkCmpts[i].reserve(numType);
-		for (const auto& type : locator.CmptAccessTypes())
+		for (const auto& type : locator.AccessTypeIDs())
 			chunkCmpts[i].emplace_back(type, data + Offsetof(type));
 		chunkEntity[i] = reinterpret_cast<Entity*>(data + offsetEntity);
 	}
 
-	vector<size_t> sizes;
+	vector<std::size_t> sizes;
 	sizes.reserve(numType);
-	for (const auto& type : locator.CmptAccessTypes())
+	for (const auto& type : locator.AccessTypeIDs())
 		sizes.push_back(cmptTraits.Sizeof(type));
 
 	return { chunkEntity, chunkCmpts, sizes };
 }
 
-void* Archetype::Locate(size_t chunkIdx, CmptType t) const {
+void* Archetype::Locate(std::size_t chunkIdx, TypeID t) const {
 	assert(chunkIdx < chunks.size());
 	if (!types.Contains(t))
 		return nullptr;
@@ -241,23 +241,23 @@ void* Archetype::Locate(size_t chunkIdx, CmptType t) const {
 	return buffer + Offsetof(t);
 }
 
-size_t Archetype::Erase(size_t idx) {
+std::size_t Archetype::Erase(std::size_t idx) {
 	assert(idx < entityNum);
 
-	size_t dstIdxInChunk = idx % chunkCapacity;
+	std::size_t dstIdxInChunk = idx % chunkCapacity;
 	byte* dstBuffer = chunks[idx / chunkCapacity]->Data();
 
-	size_t movedIdx = static_cast<size_t>(-1);
+	std::size_t movedIdx = static_cast<std::size_t>(-1);
 	
 	if (idx != entityNum - 1) {
-		size_t movedIdxInArchetype = entityNum - 1;
+		std::size_t movedIdxInArchetype = entityNum - 1;
 
-		size_t srcIdxInChunk = movedIdxInArchetype % chunkCapacity;
+		std::size_t srcIdxInChunk = movedIdxInArchetype % chunkCapacity;
 		byte* srcBuffer = chunks[movedIdxInArchetype / chunkCapacity]->Data();
 
 		for (const auto& type : types.data) {
-			size_t size = cmptTraits.Sizeof(type);
-			size_t offset = Offsetof(type);
+			std::size_t size = cmptTraits.Sizeof(type);
+			std::size_t offset = Offsetof(type);
 			byte* dst = dstBuffer + offset + dstIdxInChunk * size;
 			byte* src = srcBuffer + offset + srcIdxInChunk * size;
 
@@ -270,8 +270,8 @@ size_t Archetype::Erase(size_t idx) {
 	}
 	else {
 		for (const auto& type : types.data) {
-			size_t size = cmptTraits.Sizeof(type);
-			size_t offset = Offsetof(type);
+			std::size_t size = cmptTraits.Sizeof(type);
+			std::size_t offset = Offsetof(type);
 			byte* dst = dstBuffer + offset + dstIdxInChunk * size;
 			cmptTraits.Destruct(type, dst);
 		}
@@ -281,14 +281,14 @@ size_t Archetype::Erase(size_t idx) {
 
 	if (chunks.size() * chunkCapacity - entityNum >= chunkCapacity) {
 		Chunk* chunk = chunks.back();
-		chunkPool->Recycle(chunk);
+		chunkAllocator.deallocate(chunk, 1);
 		chunks.pop_back();
 	}
 
 	return movedIdx;
 }
 
-vector<CmptPtr> Archetype::Components(size_t idx) const {
+vector<CmptPtr> Archetype::Components(std::size_t idx) const {
 	vector<CmptPtr> rst;
 
 	for (const auto& type : types.data) {
@@ -300,7 +300,7 @@ vector<CmptPtr> Archetype::Components(size_t idx) const {
 	return rst;
 }
 
-size_t Archetype::EntityNumOfChunk(size_t chunkIdx) const noexcept {
+std::size_t Archetype::EntityNumOfChunk(std::size_t chunkIdx) const noexcept {
 	assert(chunkIdx < chunks.size());
 
 	if (chunkIdx == chunks.size() - 1)
@@ -309,15 +309,15 @@ size_t Archetype::EntityNumOfChunk(size_t chunkIdx) const noexcept {
 		return chunkCapacity;
 }
 
-CmptTypeSet Archetype::GenCmptTypeSet(Span<const CmptType> types) {
+TypeIDSet Archetype::GenTypeIDSet(std::span<const TypeID> types) {
 	assert(NotContainEntity(types));
-	CmptTypeSet typeset;
+	TypeIDSet typeset;
 	typeset.Insert(types);
-	typeset.data.insert(CmptType::Of<Entity>);
+	typeset.data.insert(TypeID_of<Entity>);
 	return typeset;
 }
 
-bool Archetype::NotContainEntity(Span<const CmptType> types) noexcept {
+bool Archetype::NotContainEntity(std::span<const TypeID> types) noexcept {
 	for (const auto& type : types) {
 		if (type.Is<Entity>())
 			return false;
diff --git a/src/core/ArchetypeFilter.cpp b/src/core/ArchetypeFilter.cpp
index f03174d..e3aa618 100644
--- a/src/core/ArchetypeFilter.cpp
+++ b/src/core/ArchetypeFilter.cpp
@@ -4,18 +4,18 @@
 
 using namespace Ubpa::UECS;
 
-size_t ArchetypeFilter::HashCode() const noexcept {
-	size_t rst = TypeID<ArchetypeFilter>;
+std::size_t ArchetypeFilter::GetValue() const noexcept {
+	std::size_t rst = TypeID_of<ArchetypeFilter>.GetValue();
 	for (const auto& type : all)
-		rst = hash_combine(rst, type.HashCode());
+		rst = hash_combine(rst, type.GetValue());
 	for (const auto& type : any)
-		rst = hash_combine(rst, type.HashCode());
+		rst = hash_combine(rst, type.GetValue());
 	for (const auto& type : none)
-		rst = hash_combine(rst, type.HashCode());
+		rst = hash_combine(rst, type.GetValue());
 	return rst;
 }
 
-bool ArchetypeFilter::HaveWriteCmptType() const noexcept {
+bool ArchetypeFilter::HaveWriteTypeID() const noexcept {
 	for (const auto& type : all) {
 		if (type.GetAccessMode() == AccessMode::WRITE)
 			return true;
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index c827b1a..36630be 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -4,7 +4,6 @@ Ubpa_AddTarget(
     "${PROJECT_SOURCE_DIR}/include/UECS"
   LIB
     Ubpa::UTemplate_core
-    Ubpa::UContainer_core
     Ubpa::UGraphviz_core
   INC
     "${PROJECT_SOURCE_DIR}/include"
diff --git a/src/core/Chunk.cpp b/src/core/Chunk.cpp
index 3f73e81..cb283c3 100644
--- a/src/core/Chunk.cpp
+++ b/src/core/Chunk.cpp
@@ -5,31 +5,31 @@
 using namespace Ubpa::UECS;
 using namespace std;
 
-Chunk::Layout Chunk::GenLayout(const vector<size_t>& alignments, const vector<size_t>& sizes) noexcept {
+Chunk::Layout Chunk::GenLayout(const vector<std::size_t>& alignments, const vector<std::size_t>& sizes) noexcept {
 	Layout layout;
 
 	// alignment isn't sorted
 	struct Item {
-		size_t alignment;
-		size_t idx;
+		std::size_t alignment;
+		std::size_t idx;
 		bool operator<(const Item& y)const noexcept {
 			return alignment < y.alignment;
 		}
 	};
 	vector<Item> items(sizes.size());
-	for (size_t i = 0; i < sizes.size(); i++)
+	for (std::size_t i = 0; i < sizes.size(); i++)
 		items[i] = Item{ alignments[i], i };
 	sort(items.begin(), items.end());
 
-	constexpr size_t chunkSize = 16 * 1024;
-	size_t sumSize = 0;
-	for (size_t s : sizes)
+	constexpr std::size_t chunkSize = 16 * 1024;
+	std::size_t sumSize = 0;
+	for (std::size_t s : sizes)
 		sumSize += s;
 	layout.capacity = chunkSize / sumSize;
 
 	layout.offsets.resize(sizes.size());
-	size_t curOffset = 0;
-	for (size_t i = 0; i < sizes.size(); i++) {
+	std::size_t curOffset = 0;
+	for (std::size_t i = 0; i < sizes.size(); i++) {
 		curOffset = items[i].alignment * ((curOffset + items[i].alignment - 1) / items[i].alignment);
 		layout.offsets[items[i].idx] = curOffset;
 		curOffset += sizes[items[i].idx] * layout.capacity;
diff --git a/src/core/ChunkView.cpp b/src/core/ChunkView.cpp
index 4de9cb0..de70d3a 100644
--- a/src/core/ChunkView.cpp
+++ b/src/core/ChunkView.cpp
@@ -4,13 +4,13 @@
 
 using namespace Ubpa::UECS;
 
-ChunkView::ChunkView(Archetype* archetype, size_t chunkIdx) noexcept
+ChunkView::ChunkView(Archetype* archetype, std::size_t chunkIdx) noexcept
 	: archetype{ archetype }, chunkIdx{ chunkIdx }, entityNum{ archetype->EntityNumOfChunk(chunkIdx) } {}
 
-void* ChunkView::GetCmptArray(CmptType t) const {
+void* ChunkView::GetCmptArray(TypeID t) const {
 	return archetype->Locate(chunkIdx, t);
 }
 
-bool ChunkView::Contains(CmptType t) const {
-	return archetype->GetCmptTypeSet().Contains(t);
+bool ChunkView::Contains(TypeID t) const {
+	return archetype->GetTypeIDSet().Contains(t);
 }
diff --git a/src/core/CmptLocator.cpp b/src/core/CmptLocator.cpp
index 58ef9e0..c59d73b 100644
--- a/src/core/CmptLocator.cpp
+++ b/src/core/CmptLocator.cpp
@@ -4,30 +4,30 @@
 
 using namespace Ubpa::UECS;
 
-CmptLocator::CmptLocator(CmptAccessTypeSet cmptTypes)
+CmptLocator::CmptLocator(AccessTypeIDSet cmptTypes)
 	: cmptTypes{ std::move(cmptTypes) }
 {
-	UpdateHashCode();
+	UpdateGetValue();
 }
 
-CmptLocator::CmptLocator(Span<const CmptAccessType> types) {
+CmptLocator::CmptLocator(std::span<const AccessTypeID> types) {
 	for (const auto& type : types)
 		cmptTypes.insert(type);
 
-	UpdateHashCode();
+	UpdateGetValue();
 }
 
 CmptLocator::CmptLocator()
-	: hashCode{ TypeID<CmptLocator> } {}
+	: hashCode{ TypeID_of<CmptLocator>.GetValue() } {}
 
-void CmptLocator::UpdateHashCode() noexcept {
-	size_t rst = TypeID<CmptLocator>;
+void CmptLocator::UpdateGetValue() noexcept {
+	std::size_t rst = TypeID_of<CmptLocator>.GetValue();
 	for (const auto& type : cmptTypes)
-		rst = hash_combine(rst, type.HashCode());
+		rst = hash_combine(rst, type.GetValue());
 	hashCode = rst;
 }
 
-bool CmptLocator::HasWriteCmptType() const noexcept {
+bool CmptLocator::HasWriteTypeID() const noexcept {
 	for (const auto& type : cmptTypes) {
 		if (type.GetAccessMode() == AccessMode::WRITE)
 			return true;
diff --git a/src/core/CmptsView.cpp b/src/core/CmptsView.cpp
index a3ceced..0862400 100644
--- a/src/core/CmptsView.cpp
+++ b/src/core/CmptsView.cpp
@@ -2,7 +2,7 @@
 
 using namespace Ubpa::UECS;
 
-CmptAccessPtr CmptsView::GetCmpt(CmptAccessType t) const noexcept {
+CmptAccessPtr CmptsView::GetCmpt(AccessTypeID t) const noexcept {
 	for(const auto& cmpt : cmpts) {
 		if (cmpt.AccessType() == t)
 			return cmpt;
diff --git a/src/core/EntityMngr.cpp b/src/core/EntityMngr.cpp
index a4822e8..868debc 100644
--- a/src/core/EntityMngr.cpp
+++ b/src/core/EntityMngr.cpp
@@ -7,22 +7,22 @@ using namespace Ubpa::UECS;
 using namespace std;
 
 EntityMngr::EntityMngr()
-	: sharedChunkPool{ std::make_unique<Pool<Chunk>>() }
+	: rsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() }
 {}
 
 EntityMngr::EntityMngr(const EntityMngr& em)
 	:
 	cmptTraits{ em.cmptTraits },
-	sharedChunkPool{ std::make_unique<Pool<Chunk>>() }
+	rsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() }
 {
 	ts2a.reserve(em.ts2a.size());
 	for (const auto& [ts, a] : em.ts2a) {
-		auto [iter, success] = ts2a.try_emplace(ts, std::make_unique<Archetype>(sharedChunkPool.get(), *a));
+		auto [iter, success] = ts2a.try_emplace(ts, std::make_unique<Archetype>(std::pmr::polymorphic_allocator<Chunk>{rsrc.get()}, * a));
 		assert(success);
 	}
 	entityTableFreeEntry = em.entityTableFreeEntry;
 	entityTable.resize(em.entityTable.size());
-	for (size_t i = 0; i < em.entityTable.size(); i++) {
+	for (std::size_t i = 0; i < em.entityTable.size(); i++) {
 		auto& dst = entityTable[i];
 		const auto& src = em.entityTable[i];
 		dst.idxInArchetype = src.idxInArchetype;
@@ -40,17 +40,16 @@ EntityMngr::EntityMngr(const EntityMngr& em)
 
 EntityMngr::~EntityMngr() {
 	ts2a.clear();
-	sharedChunkPool->FastClear();
 }
 
-size_t EntityMngr::RequestEntityFreeEntry() {
+std::size_t EntityMngr::RequestEntityFreeEntry() {
 	if (entityTableFreeEntry.empty()) {
-		size_t index = entityTable.size();
+		std::size_t index = entityTable.size();
 		entityTable.emplace_back();
 		return index;
 	}
 
-	size_t entry = entityTableFreeEntry.back();
+	std::size_t entry = entityTableFreeEntry.back();
 	entityTableFreeEntry.pop_back();
 	return entry;
 }
@@ -60,32 +59,32 @@ void EntityMngr::RecycleEntityEntry(Entity e) {
 
 	auto& info = entityTable[e.Idx()];
 	info.archetype = nullptr;
-	info.idxInArchetype = static_cast<size_t>(-1);
+	info.idxInArchetype = static_cast<std::size_t>(-1);
 	info.version++;
 
 	entityTableFreeEntry.push_back(e.Idx());
 }
 
-Archetype* EntityMngr::GetOrCreateArchetypeOf(Span<const CmptType> types) {
-	auto typeset = Archetype::GenCmptTypeSet(types);
+Archetype* EntityMngr::GetOrCreateArchetypeOf(std::span<const TypeID> types) {
+	auto typeset = Archetype::GenTypeIDSet(types);
 	auto target = ts2a.find(typeset);
 	if (target != ts2a.end())
 		return target->second.get();
 
-	auto* archetype = Archetype::New(cmptTraits, sharedChunkPool.get(), types);
+	auto* archetype = Archetype::New(cmptTraits, std::pmr::polymorphic_allocator<Chunk>{rsrc.get()}, types);
 
 	ts2a.emplace(std::move(typeset), std::unique_ptr<Archetype>{ archetype });
 	for (auto& [query, archetypes] : queryCache) {
-		if (archetype->GetCmptTypeSet().IsMatch(query))
+		if (archetype->GetTypeIDSet().IsMatch(query))
 			archetypes.insert(archetype);
 	}
 
 	return archetype;
 }
 
-Entity EntityMngr::Create(Span<const CmptType> types) {
+Entity EntityMngr::Create(std::span<const TypeID> types) {
 	Archetype* archetype = GetOrCreateArchetypeOf(types);
-	size_t entityIndex = RequestEntityFreeEntry();
+	std::size_t entityIndex = RequestEntityFreeEntry();
 	auto& info = entityTable[entityIndex];
 	Entity e{ entityIndex, info.version };
 	info.archetype = archetype;
@@ -93,29 +92,29 @@ Entity EntityMngr::Create(Span<const CmptType> types) {
 	return e;
 }
 
-Archetype* EntityMngr::AttachWithoutInit(Entity e, Span<const CmptType> types) {
+Archetype* EntityMngr::AttachWithoutInit(Entity e, std::span<const TypeID> types) {
 	assert(IsSet(types));
 	if (!Exist(e)) throw std::invalid_argument("Entity is invalid");
 
 	auto& info = entityTable[e.Idx()];
 	Archetype* srcArchetype = info.archetype;
-	size_t srcIdxInArchetype = info.idxInArchetype;
+	std::size_t srcIdxInArchetype = info.idxInArchetype;
 
-	const auto& srcCmptTypeSet = srcArchetype->GetCmptTypeSet();
-	auto dstCmptTypeSet = srcCmptTypeSet;
-	dstCmptTypeSet.Insert(types);
+	const auto& srcTypeIDSet = srcArchetype->GetTypeIDSet();
+	auto dstTypeIDSet = srcTypeIDSet;
+	dstTypeIDSet.Insert(types);
 
 	// get dstArchetype
 	Archetype* dstArchetype;
-	auto target = ts2a.find(dstCmptTypeSet);
+	auto target = ts2a.find(dstTypeIDSet);
 	if (target == ts2a.end()) {
 		dstArchetype = Archetype::Add(cmptTraits, srcArchetype, types);
-		assert(dstCmptTypeSet == dstArchetype->GetCmptTypeSet());
+		assert(dstTypeIDSet == dstArchetype->GetTypeIDSet());
 		for (auto& [query, archetypes] : queryCache) {
-			if (dstCmptTypeSet.IsMatch(query))
+			if (dstTypeIDSet.IsMatch(query))
 				archetypes.insert(dstArchetype);
 		}
-		ts2a.emplace(std::move(dstCmptTypeSet), std::unique_ptr<Archetype>{dstArchetype});
+		ts2a.emplace(std::move(dstTypeIDSet), std::unique_ptr<Archetype>{dstArchetype});
 	}
 	else {
 		dstArchetype = target->second.get();
@@ -124,10 +123,10 @@ Archetype* EntityMngr::AttachWithoutInit(Entity e, Span<const CmptType> types) {
 	}
 
 	// move src to dst
-	size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
+	std::size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
 
 	const auto& srcCmptTraits = srcArchetype->GetArchetypeCmptTraits();
-	for (const auto& type : srcCmptTypeSet.data) {
+	for (const auto& type : srcTypeIDSet.data) {
 		auto* srcCmpt = srcArchetype->At(type, srcIdxInArchetype);
 		auto* dstCmpt = dstArchetype->At(type, dstIdxInArchetype);
 		srcCmptTraits.MoveConstruct(type, dstCmpt, srcCmpt);
@@ -135,7 +134,7 @@ Archetype* EntityMngr::AttachWithoutInit(Entity e, Span<const CmptType> types) {
 
 	// erase
 	auto srcMovedEntityIndex = srcArchetype->Erase(srcIdxInArchetype);
-	if (srcMovedEntityIndex != static_cast<size_t>(-1))
+	if (srcMovedEntityIndex != static_cast<std::size_t>(-1))
 		entityTable[srcMovedEntityIndex].idxInArchetype = srcIdxInArchetype;
 
 	info.archetype = dstArchetype;
@@ -144,11 +143,11 @@ Archetype* EntityMngr::AttachWithoutInit(Entity e, Span<const CmptType> types) {
 	return srcArchetype;
 }
 
-void EntityMngr::Attach(Entity e, Span<const CmptType> types) {
+void EntityMngr::Attach(Entity e, std::span<const TypeID> types) {
 	auto* origArchetype = AttachWithoutInit(e, types);
 	const auto& info = entityTable[e.Idx()];
 	for (const auto& type : types) {
-		if (origArchetype->GetCmptTypeSet().Contains(type))
+		if (origArchetype->GetTypeIDSet().Contains(type))
 			continue;
 
 		auto target = cmptTraits.GetDefaultConstructors().find(type);
@@ -159,27 +158,27 @@ void EntityMngr::Attach(Entity e, Span<const CmptType> types) {
 	}
 }
 
-void EntityMngr::Detach(Entity e, Span<const CmptType> types) {
+void EntityMngr::Detach(Entity e, std::span<const TypeID> types) {
 	assert(IsSet(types));
 	if (!Exist(e)) throw std::invalid_argument("EntityMngr::Detach: Entity is invalid");
 
 	auto& info = entityTable[e.Idx()];
 	Archetype* srcArchetype = info.archetype;
 
-	const auto& srcCmptTypeSet = srcArchetype->GetCmptTypeSet();
-	auto dstCmptTypeSet = srcCmptTypeSet;
-	dstCmptTypeSet.Erase(types);
+	const auto& srcTypeIDSet = srcArchetype->GetTypeIDSet();
+	auto dstTypeIDSet = srcTypeIDSet;
+	dstTypeIDSet.Erase(types);
 
 	// get dstArchetype
 	Archetype* dstArchetype;
 	bool isNewArchetype;
-	auto target = ts2a.find(dstCmptTypeSet);
+	auto target = ts2a.find(dstTypeIDSet);
 	if (target == ts2a.end()) {
 		isNewArchetype = true;
 		dstArchetype = Archetype::Remove(srcArchetype, types);
-		assert(dstCmptTypeSet == dstArchetype->GetCmptTypeSet());
+		assert(dstTypeIDSet == dstArchetype->GetTypeIDSet());
 		for (auto& [query, archetypes] : queryCache) {
-			if (dstCmptTypeSet.IsMatch(query))
+			if (dstTypeIDSet.IsMatch(query))
 				archetypes.insert(dstArchetype);
 		}
 	}
@@ -191,26 +190,26 @@ void EntityMngr::Detach(Entity e, Span<const CmptType> types) {
 	}
 
 	// move src to dst
-	size_t srcIdxInArchetype = info.idxInArchetype;
-	size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
+	std::size_t srcIdxInArchetype = info.idxInArchetype;
+	std::size_t dstIdxInArchetype = dstArchetype->RequestBuffer();
 
 	const auto& srcCmptTraits = srcArchetype->GetArchetypeCmptTraits();
-	for (const auto& type : dstCmptTypeSet.data) {
+	for (const auto& type : dstTypeIDSet.data) {
 		auto* srcCmpt = srcArchetype->At(type, srcIdxInArchetype);
 		auto* dstCmpt = dstArchetype->At(type, dstIdxInArchetype);
 		srcCmptTraits.MoveConstruct(type, dstCmpt, srcCmpt);
 	}
 
 	// erase
-	size_t srcMovedEntityIndex = srcArchetype->Erase(srcIdxInArchetype); // call destructor
-	if (srcMovedEntityIndex != static_cast<size_t>(-1))
+	std::size_t srcMovedEntityIndex = srcArchetype->Erase(srcIdxInArchetype); // call destructor
+	if (srcMovedEntityIndex != static_cast<std::size_t>(-1))
 		entityTable[srcMovedEntityIndex].idxInArchetype = srcIdxInArchetype;
 
 	info.archetype = dstArchetype;
 	info.idxInArchetype = dstIdxInArchetype;
 
 	if(isNewArchetype)
-		ts2a.emplace(std::move(dstCmptTypeSet), std::unique_ptr<Archetype>{dstArchetype});
+		ts2a.emplace(std::move(dstTypeIDSet), std::unique_ptr<Archetype>{dstArchetype});
 }
 
 vector<CmptPtr> EntityMngr::Components(Entity e) const {
@@ -223,19 +222,19 @@ vector<CmptPtr> EntityMngr::Components(Entity e) const {
 Entity EntityMngr::Instantiate(Entity srcEntity) {
 	if (!Exist(srcEntity)) throw std::invalid_argument("Entity is invalid");
 
-	size_t dstEntityIndex = RequestEntityFreeEntry();
+	std::size_t dstEntityIndex = RequestEntityFreeEntry();
 	const auto& srcInfo = entityTable[srcEntity.Idx()];
 	auto& dstInfo = entityTable[dstEntityIndex];
 	Entity dstEntity{ dstEntityIndex, dstInfo.version };
-	size_t dstIndexInArchetype = srcInfo.archetype->Instantiate(dstEntity, srcInfo.idxInArchetype);
+	std::size_t dstIndexInArchetype = srcInfo.archetype->Instantiate(dstEntity, srcInfo.idxInArchetype);
 	dstInfo.archetype = srcInfo.archetype;
 	dstInfo.idxInArchetype = dstIndexInArchetype;
 	return dstEntity;
 }
 
-bool EntityMngr::IsSet(Span<const CmptType> types) noexcept {
-	for (size_t i = 0; i < types.size(); i++) {
-		for (size_t j = 0; j < i; j++)
+bool EntityMngr::IsSet(std::span<const TypeID> types) noexcept {
+	for (std::size_t i = 0; i < types.size(); i++) {
+		for (std::size_t j = 0; j < i; j++)
 			if (types[i] == types[j])
 				return false;
 	}
@@ -251,15 +250,15 @@ const set<Archetype*>& EntityMngr::QueryArchetypes(const EntityQuery& query) con
 	// queryCache is **mutable**
 	set<Archetype*>& archetypes = queryCache[query];
 	for (const auto& [ts, a] : ts2a) {
-		if (a->GetCmptTypeSet().IsMatch(query))
+		if (a->GetTypeIDSet().IsMatch(query))
 			archetypes.insert(a.get());
 	}
 
 	return archetypes;
 }
 
-size_t EntityMngr::EntityNum(const EntityQuery& query) const {
-	size_t sum = 0;
+std::size_t EntityMngr::EntityNum(const EntityQuery& query) const {
+	std::size_t sum = 0;
 	for (const auto& archetype : QueryArchetypes(query))
 		sum += archetype->EntityNum();
 	return sum;
@@ -274,14 +273,14 @@ void EntityMngr::Destroy(Entity e) {
 
 	auto movedEntityIndex = archetype->Erase(idxInArchetype);
 
-	if (movedEntityIndex != static_cast<size_t>(-1))
+	if (movedEntityIndex != static_cast<std::size_t>(-1))
 		entityTable[movedEntityIndex].idxInArchetype = idxInArchetype;
 
 	RecycleEntityEntry(e);
 }
 
 vector<CmptAccessPtr> EntityMngr::LocateSingletons(const SingletonLocator& locator) const {
-	size_t numSingletons = 0;
+	std::size_t numSingletons = 0;
 	vector<CmptAccessPtr> rst;
 	rst.reserve(locator.SingletonTypes().size());
 	for (const auto& t : locator.SingletonTypes()) {
@@ -302,23 +301,23 @@ void EntityMngr::GenEntityJob(World* w, Job* job, SystemFunc* sys) const {
 	
 	if (sys->IsParallel()) {
 		assert(job);
-		size_t indexOffsetInQuery = 0;
+		std::size_t indexOffsetInQuery = 0;
 		for (Archetype* archetype : QueryArchetypes(sys->entityQuery)) {
 			auto [chunkEntity, chunkCmpts, sizes] = archetype->Locate(sys->entityQuery.locator);
 
-			size_t num = archetype->EntityNum();
-			size_t chunkNum = archetype->ChunkNum();
-			size_t chunkCapacity = archetype->ChunkCapacity();
+			std::size_t num = archetype->EntityNum();
+			std::size_t chunkNum = archetype->ChunkNum();
+			std::size_t chunkCapacity = archetype->ChunkCapacity();
 
-			for (size_t i = 0; i < chunkNum; i++) {
+			for (std::size_t i = 0; i < chunkNum; i++) {
 				job->emplace([=, sizes = sizes, entities = chunkEntity[i], cmpts = move(chunkCmpts[i]), singletons = singletons]() mutable {
-					size_t idxOffsetInChunk = i * chunkCapacity;
-					size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
-					CmptsView chunkView{ Span{cmpts.data(), cmpts.size()} };
-					SingletonsView singletonsView{ Span{singletons.data(), singletons.size()} };
+					std::size_t idxOffsetInChunk = i * chunkCapacity;
+					std::size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
+					CmptsView chunkView{ std::span{cmpts.data(), cmpts.size()} };
+					SingletonsView singletonsView{ std::span{singletons.data(), singletons.size()} };
 
-					size_t J = min(chunkCapacity, num - idxOffsetInChunk);
-					for (size_t j = 0; j < J; j++) {
+					std::size_t J = min(chunkCapacity, num - idxOffsetInChunk);
+					for (std::size_t j = 0; j < J; j++) {
 						(*sys)(
 							w,
 							singletonsView,
@@ -326,7 +325,7 @@ void EntityMngr::GenEntityJob(World* w, Job* job, SystemFunc* sys) const {
 							indexOffsetInQueryChunk + j,
 							chunkView
 						);
-						for (size_t k = 0; k < cmpts.size(); k++)
+						for (std::size_t k = 0; k < cmpts.size(); k++)
 							reinterpret_cast<uint8_t*&>(cmpts[k].p) += sizes[k];
 					}
 				});
@@ -337,22 +336,22 @@ void EntityMngr::GenEntityJob(World* w, Job* job, SystemFunc* sys) const {
 	}
 	else {
 		auto work = [this, singletons = std::move(singletons), sys, w]() {
-			size_t indexOffsetInQuery = 0;
+			std::size_t indexOffsetInQuery = 0;
 			for (Archetype* archetype : QueryArchetypes(sys->entityQuery)) {
 				auto [chunkEntity, chunkCmpts, sizes] = archetype->Locate(sys->entityQuery.locator);
 
-				size_t num = archetype->EntityNum();
-				size_t chunkNum = archetype->ChunkNum();
-				size_t chunkCapacity = archetype->ChunkCapacity();
+				std::size_t num = archetype->EntityNum();
+				std::size_t chunkNum = archetype->ChunkNum();
+				std::size_t chunkCapacity = archetype->ChunkCapacity();
 
-				for (size_t i = 0; i < chunkNum; i++) {
-					size_t idxOffsetInChunk = i * chunkCapacity;
-					size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
-					CmptsView chunkView{ Span{chunkCmpts[i].data(), chunkCmpts[i].size()} };
-					SingletonsView singletonsView{ Span{singletons.data(), singletons.size()} };
+				for (std::size_t i = 0; i < chunkNum; i++) {
+					std::size_t idxOffsetInChunk = i * chunkCapacity;
+					std::size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
+					CmptsView chunkView{ std::span{chunkCmpts[i].data(), chunkCmpts[i].size()} };
+					SingletonsView singletonsView{ std::span{singletons.data(), singletons.size()} };
 
-					size_t J = min(chunkCapacity, num - idxOffsetInChunk);
-					for (size_t j = 0; j < J; j++) {
+					std::size_t J = min(chunkCapacity, num - idxOffsetInChunk);
+					for (std::size_t j = 0; j < J; j++) {
 						(*sys)(
 							w,
 							singletonsView,
@@ -360,7 +359,7 @@ void EntityMngr::GenEntityJob(World* w, Job* job, SystemFunc* sys) const {
 							indexOffsetInQueryChunk + j,
 							chunkView
 							);
-						for (size_t k = 0; k < chunkCmpts[i].size(); k++)
+						for (std::size_t k = 0; k < chunkCmpts[i].size(); k++)
 							reinterpret_cast<uint8_t*&>(chunkCmpts[i][k].p) += sizes[k];
 					}
 				}
@@ -385,19 +384,19 @@ void EntityMngr::GenChunkJob(World* w, Job* job, SystemFunc* sys) const {
 
 	if (sys->IsParallel()) {
 		assert(job != nullptr);
-		size_t indexOffsetInQuery = 0;
+		std::size_t indexOffsetInQuery = 0;
 		for (Archetype* archetype : QueryArchetypes(sys->entityQuery)) {
-			size_t num = archetype->EntityNum();
-			size_t chunkNum = archetype->ChunkNum();
-			size_t chunkCapacity = archetype->ChunkCapacity();
+			std::size_t num = archetype->EntityNum();
+			std::size_t chunkNum = archetype->ChunkNum();
+			std::size_t chunkCapacity = archetype->ChunkCapacity();
 
-			for (size_t i = 0; i < chunkNum; i++) {
-				size_t idxOffsetInChunk = i * chunkCapacity;
-				size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
+			for (std::size_t i = 0; i < chunkNum; i++) {
+				std::size_t idxOffsetInChunk = i * chunkCapacity;
+				std::size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
 				job->emplace([=, singletons = singletons]() {
 					(*sys)(
 						w,
-						SingletonsView{ Span{singletons.data(), singletons.size()} },
+						SingletonsView{ std::span{singletons.data(), singletons.size()} },
 						indexOffsetInQueryChunk,
 						ChunkView{ archetype, i }
 					);
@@ -409,17 +408,17 @@ void EntityMngr::GenChunkJob(World* w, Job* job, SystemFunc* sys) const {
 	}
 	else {
 		auto work = [this, w, sys, singletons = std::move(singletons)]() {
-			SingletonsView singletonsView{ Span{singletons.data(), singletons.size()} };
+			SingletonsView singletonsView{ std::span{singletons.data(), singletons.size()} };
 
-			size_t indexOffsetInQuery = 0;
+			std::size_t indexOffsetInQuery = 0;
 			for (Archetype* archetype : QueryArchetypes(sys->entityQuery)) {
-				size_t num = archetype->EntityNum();
-				size_t chunkNum = archetype->ChunkNum();
-				size_t chunkCapacity = archetype->ChunkCapacity();
+				std::size_t num = archetype->EntityNum();
+				std::size_t chunkNum = archetype->ChunkNum();
+				std::size_t chunkCapacity = archetype->ChunkCapacity();
 
-				for (size_t i = 0; i < chunkNum; i++) {
-					size_t idxOffsetInChunk = i * chunkCapacity;
-					size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
+				for (std::size_t i = 0; i < chunkNum; i++) {
+					std::size_t idxOffsetInChunk = i * chunkCapacity;
+					std::size_t indexOffsetInQueryChunk = indexOffsetInQuery + idxOffsetInChunk;
 					(*sys)(
 						w,
 						singletonsView,
@@ -447,7 +446,7 @@ void EntityMngr::GenJob(World* w, Job* job, SystemFunc* sys) const {
 	auto work = [=, singletons = std::move(singletons)]() {
 		(*sys)(
 			w,
-			SingletonsView{ Span{singletons.data(), singletons.size()} }
+			SingletonsView{ std::span{singletons.data(), singletons.size()} }
 		);
 	};
 
@@ -479,7 +478,7 @@ void EntityMngr::Accept(IListener* listener) const {
 	// TODO : speed up
 	listener->EnterEntityMngr(this);
 	for (const auto& [ts, a] : ts2a) {
-		for (size_t i = 0; i < a->EntityNum(); i++) {
+		for (std::size_t i = 0; i < a->EntityNum(); i++) {
 			auto e = *a->At<Entity>(i);
 			listener->EnterEntity(e);
 			for (const auto& cmpt : a->Components(i)) {
@@ -492,8 +491,8 @@ void EntityMngr::Accept(IListener* listener) const {
 	listener->ExistEntityMngr(this);
 }
 
-bool EntityMngr::IsSingleton(CmptType t) const {
-	ArchetypeFilter filter{ {CmptAccessType{t}}, {}, {} };
+bool EntityMngr::IsSingleton(TypeID t) const {
+	ArchetypeFilter filter{ {AccessTypeID{t}}, {}, {} };
 	EntityQuery query{ move(filter) };
 	const auto& archetypes = QueryArchetypes(query);
 	if (archetypes.size() != 1)
@@ -505,60 +504,60 @@ bool EntityMngr::IsSingleton(CmptType t) const {
 	return true;
 }
 
-Entity EntityMngr::GetSingletonEntity(CmptType t) const {
+Entity EntityMngr::GetSingletonEntity(TypeID t) const {
 	assert(IsSingleton(t));
-	ArchetypeFilter filter{ {CmptAccessType{t}}, {}, {} };
+	ArchetypeFilter filter{ {AccessTypeID{t}}, {}, {} };
 	EntityQuery query{ move(filter) };
 	const auto& archetypes = QueryArchetypes(query);
 	auto* archetype = *archetypes.begin();
 	return *archetype->At<Entity>(0);
 }
 
-CmptPtr EntityMngr::GetSingleton(CmptType t) const {
-	ArchetypeFilter filter{ {CmptAccessType{t}}, {}, {} };
+CmptPtr EntityMngr::GetSingleton(TypeID t) const {
+	ArchetypeFilter filter{ {AccessTypeID{t}}, {}, {} };
 	EntityQuery query{ move(filter) };
 	const auto& archetypes = QueryArchetypes(query);
 
-	size_t num = 0;
+	std::size_t num = 0;
 	for (auto* archetype : archetypes)
 		num += archetype->EntityNum();
 
 	if (num != 1)
-		return { CmptType::Invalid(), nullptr };
+		return { TypeID{}, nullptr };
 
 	for (auto* archetype : archetypes) {
 		if (archetype->EntityNum() != 0)
 			return { t, archetype->At(t, 0) };
 	}
 
-	return { CmptType::Invalid(), nullptr };
+	return { TypeID{}, nullptr };
 }
 
-std::vector<CmptPtr> EntityMngr::GetCmptArray(const ArchetypeFilter& filter, CmptType type) const {
-	assert(filter.all.find(CmptAccessType{ type }) != filter.all.end());
+std::vector<CmptPtr> EntityMngr::GetCmptArray(const ArchetypeFilter& filter, TypeID type) const {
+	assert(filter.all.find(AccessTypeID{ type }) != filter.all.end());
 
 	std::vector<CmptPtr> rst;
 
 	const auto& archetypes = QueryArchetypes(EntityQuery{ filter });
 
-	size_t num = 0;
+	std::size_t num = 0;
 	for (const auto& archetype : archetypes)
 		num += archetype->EntityNum();
 
 	rst.reserve(num);
 	for (auto* archetype : archetypes) {
-		/*for (size_t i = 0; i < archetype->EntityNum(); i++)
+		/*for (std::size_t i = 0; i < archetype->EntityNum(); i++)
 			rst[idx++] = *archetype->At(type, i);*/
 
 		// speed up
 
-		size_t size = archetype->cmptTraits.Sizeof(type);
-		size_t offset = archetype->Offsetof(type);
-		for (size_t c = 0; c < archetype->chunks.size(); c++) {
+		std::size_t size = archetype->cmptTraits.Sizeof(type);
+		std::size_t offset = archetype->Offsetof(type);
+		for (std::size_t c = 0; c < archetype->chunks.size(); c++) {
 			auto* buffer = archetype->chunks[c]->Data();
 			auto* beg = buffer + offset;
-			size_t chunkSize = archetype->EntityNumOfChunk(c);
-			for (size_t i = 0; i < chunkSize; i++)
+			std::size_t chunkSize = archetype->EntityNumOfChunk(c);
+			for (std::size_t i = 0; i < chunkSize; i++)
 				rst.emplace_back(type, beg + i * size);
 		}
 	}
@@ -571,23 +570,23 @@ std::vector<Entity> EntityMngr::GetEntityArray(const ArchetypeFilter& filter) co
 
 	const auto& archetypes = QueryArchetypes(EntityQuery{ filter });
 
-	size_t num = 0;
+	std::size_t num = 0;
 	for (const auto& archetype : archetypes)
 		num += archetype->EntityNum();
 
 	rst.reserve(num);
 	for (auto* archetype : archetypes) {
-		/*for (size_t i = 0; i < archetype->EntityNum(); i++)
+		/*for (std::size_t i = 0; i < archetype->EntityNum(); i++)
 			rst[idx++] = *archetype->At<Entity>(i);*/
 
 		// speed up
 
-		size_t offset = archetype->Offsetof(CmptType::Of<Entity>);
-		for (size_t c = 0; c < archetype->chunks.size(); c++) {
+		std::size_t offset = archetype->Offsetof(TypeID_of<Entity>);
+		for (std::size_t c = 0; c < archetype->chunks.size(); c++) {
 			auto* buffer = archetype->chunks[c]->Data();
 			auto* beg = buffer + offset;
-			size_t chunkSize = archetype->EntityNumOfChunk(c);
-			for (size_t i = 0; i < chunkSize; i++)
+			std::size_t chunkSize = archetype->EntityNumOfChunk(c);
+			for (std::size_t i = 0; i < chunkSize; i++)
 				rst.push_back(*reinterpret_cast<Entity*>(beg + i * sizeof(Entity)));
 		}
 	}
diff --git a/src/core/Schedule.cpp b/src/core/Schedule.cpp
index 315d04a..494a4ef 100644
--- a/src/core/Schedule.cpp
+++ b/src/core/Schedule.cpp
@@ -1,9 +1,8 @@
 #include <UECS/Schedule.h>
 
-#include <UContainer/Algorithm.h>
-
 #include "SysFuncGraph.h"
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
@@ -13,26 +12,20 @@ namespace Ubpa::UECS::detail {
 		NoneGroup(SystemFunc* func)
 			: sysFuncs{ func }
 		{
-			allTypes = SetUnion(func->entityQuery.filter.all, func->entityQuery.locator.CmptAccessTypes());
+			std::set_union(
+				func->entityQuery.filter.all.begin(),
+				func->entityQuery.filter.all.end(),
+				func->entityQuery.locator.AccessTypeIDs().begin(),
+				func->entityQuery.locator.AccessTypeIDs().end(),
+				std::insert_iterator<AccessTypeIDSet>(allTypes, allTypes.begin())
+			);
+
 			anyTypes = func->entityQuery.filter.any;
 			randomTypes = func->randomAccessor.types;
 			noneTypes = func->entityQuery.filter.none;
 		}
 
 		static bool Parallelable(const NoneGroup& x, const NoneGroup& y) {
-			//{ // subgraph
-			//	const NoneGroup& minG = x.sysFuncs.size() < y.sysFuncs.size() ? x : y;
-			//	const NoneGroup& maxG = x.sysFuncs.size() < y.sysFuncs.size() ? y : x;
-			//	bool flag = true;
-			//	for(auto* f : minG.sysFuncs) {
-			//		if(maxG.sysFuncs.find(f) == maxG.sysFuncs.end()) {
-			//			flag = false;
-			//			break;
-			//		}
-			//	}
-			//	if (flag)
-			//		return true;
-			//}
 			if (y.randomTypes.empty() && !y.noneTypes.empty()) { // y.none
 				bool allFlag = false;
 				bool anyFlag = true;
@@ -42,9 +35,9 @@ namespace Ubpa::UECS::detail {
 					auto x_iter = x.allTypes.begin();
 					auto y_iter = y.noneTypes.begin();
 					while (x_iter != x.allTypes.end() && y_iter != y.noneTypes.end()) {
-						if (x_iter->GetCmptType() < *y_iter)
+						if (*x_iter < *y_iter)
 							++x_iter;
-						else if (x_iter->GetCmptType() > * y_iter)
+						else if (*x_iter > * y_iter)
 							++y_iter;
 						else { // == 
 							allFlag = true;
@@ -60,12 +53,12 @@ namespace Ubpa::UECS::detail {
 						auto x_iter = x.anyTypes.begin();
 						auto y_iter = y.noneTypes.begin();
 						while (x_iter != x.anyTypes.end()) {
-							if (y_iter == y.noneTypes.end() || x_iter->GetCmptType() < *y_iter) {
+							if (y_iter == y.noneTypes.end() || *x_iter < *y_iter) {
 								anyFlag = false;
 								break;
 							}
 
-							if (x_iter->GetCmptType() == *y_iter)
+							if (*x_iter == *y_iter)
 								++x_iter;
 
 							++y_iter;
@@ -77,12 +70,12 @@ namespace Ubpa::UECS::detail {
 					auto x_iter = x.randomTypes.begin();
 					auto y_iter = y.noneTypes.begin();
 					while (x_iter != x.randomTypes.end() && y_iter != y.noneTypes.end()) {
-						if (x_iter->GetCmptType() < *y_iter) {
+						if (*x_iter < *y_iter) {
 							randomFlag = false;
 							break;
 						}
 
-						if (x_iter->GetCmptType() == *y_iter)
+						if (*x_iter == *y_iter)
 							++x_iter;
 
 						++y_iter;
@@ -99,9 +92,9 @@ namespace Ubpa::UECS::detail {
 					auto x_iter = x.noneTypes.begin();
 					auto y_iter = y.allTypes.begin();
 					while (x_iter != x.noneTypes.end() && y_iter != y.allTypes.end()) {
-						if (*x_iter < y_iter->GetCmptType())
+						if (*x_iter < *y_iter)
 							++x_iter;
-						else if (*x_iter > y_iter->GetCmptType())
+						else if (*x_iter > *y_iter)
 							++y_iter;
 						else { // == 
 							allFlag = true;
@@ -117,12 +110,12 @@ namespace Ubpa::UECS::detail {
 						auto x_iter = x.noneTypes.begin();
 						auto y_iter = y.anyTypes.begin();
 						while (x_iter != x.noneTypes.end()) {
-							if (y_iter == y.anyTypes.end() || y_iter->GetCmptType() < *x_iter) {
+							if (y_iter == y.anyTypes.end() || *y_iter < *x_iter) {
 								anyFlag = false;
 								break;
 							}
 
-							if (y_iter->GetCmptType() == *x_iter)
+							if (*y_iter == *x_iter)
 								++y_iter;
 
 							++x_iter;
@@ -134,12 +127,12 @@ namespace Ubpa::UECS::detail {
 					auto x_iter = x.noneTypes.begin();
 					auto y_iter = y.randomTypes.begin();
 					while (x_iter != x.noneTypes.end() && y_iter != y.randomTypes.end()) {
-						if (y_iter->GetCmptType() < *x_iter) {
+						if (*y_iter < *x_iter) {
 							randomFlag = false;
 							break;
 						}
 
-						if (y_iter->GetCmptType() == *x_iter)
+						if (*y_iter == *x_iter)
 							++y_iter;
 
 						++x_iter;
@@ -152,19 +145,72 @@ namespace Ubpa::UECS::detail {
 		}
 
 		NoneGroup& operator+=(const NoneGroup& y) {
-			allTypes = SetIntersection(allTypes, y.allTypes);
-			anyTypes = SetUnion(anyTypes, y.anyTypes);
-			anyTypes = SetUnion(anyTypes, SetSymmetricDifference(allTypes, y.allTypes));
-			randomTypes = SetUnion(randomTypes, y.randomTypes);
-			noneTypes = SetIntersection(noneTypes, y.noneTypes);
-			sysFuncs = SetUnion(sysFuncs, y.sysFuncs);
+			AccessTypeIDSet rst_allTypes, rst_anyTypes, rst_randomTypes,
+				union_anyTypes, diff_allTypes;
+			set<TypeID> rst_noneTypes;
+			set<SystemFunc*> rst_sysFuncs;
+			std::set_intersection(
+				allTypes.begin(),
+				allTypes.end(),
+				y.allTypes.begin(),
+				y.allTypes.end(),
+				std::insert_iterator<AccessTypeIDSet>(rst_allTypes, rst_allTypes.begin())
+			);
+			std::set_union(
+				anyTypes.begin(),
+				anyTypes.end(),
+				y.anyTypes.begin(),
+				y.anyTypes.end(),
+				std::insert_iterator<AccessTypeIDSet>(union_anyTypes, union_anyTypes.begin())
+			);
+			std::set_symmetric_difference(
+				allTypes.begin(),
+				allTypes.end(),
+				y.allTypes.begin(),
+				y.allTypes.end(),
+				std::insert_iterator<AccessTypeIDSet>(diff_allTypes, diff_allTypes.begin())
+			);
+			std::set_union(
+				union_anyTypes.begin(),
+				union_anyTypes.end(),
+				diff_allTypes.begin(),
+				diff_allTypes.end(),
+				std::insert_iterator<AccessTypeIDSet>(rst_anyTypes, rst_anyTypes.begin())
+			);
+			std::set_union(
+				randomTypes.begin(),
+				randomTypes.end(),
+				y.randomTypes.begin(),
+				y.randomTypes.end(),
+				std::insert_iterator<AccessTypeIDSet>(rst_randomTypes, rst_randomTypes.begin())
+			);
+			std::set_intersection(
+				noneTypes.begin(),
+				noneTypes.end(),
+				y.noneTypes.begin(),
+				y.noneTypes.end(),
+				std::insert_iterator<set<TypeID>>(rst_noneTypes, rst_noneTypes.begin())
+			);
+			std::set_union(
+				sysFuncs.begin(),
+				sysFuncs.end(),
+				y.sysFuncs.begin(),
+				y.sysFuncs.end(),
+				std::insert_iterator<set<SystemFunc*>>(rst_sysFuncs, rst_sysFuncs.begin())
+			);
+
+			allTypes = std::move(rst_allTypes);
+			anyTypes = std::move(rst_anyTypes);
+			randomTypes = std::move(rst_randomTypes);
+			noneTypes = std::move(rst_noneTypes);
+			sysFuncs = std::move(rst_sysFuncs);
 			return *this;
 		}
 
-		CmptAccessTypeSet allTypes;
-		CmptAccessTypeSet anyTypes;
-		CmptAccessTypeSet randomTypes;
-		set<CmptType> noneTypes;
+		AccessTypeIDSet allTypes;
+		AccessTypeIDSet anyTypes;
+		AccessTypeIDSet randomTypes;
+		set<TypeID> noneTypes;
 		set<SystemFunc*> sysFuncs;
 	};
 
@@ -182,7 +228,7 @@ namespace Ubpa::UECS::detail {
 
 			if (!preReaders.empty()) {
 				NoneGroup preGroup{ gMap.at(preReaders.front()) };
-				for (size_t i = 1; i < preReaders.size(); i++)
+				for (std::size_t i = 1; i < preReaders.size(); i++)
 					preGroup += gMap.at(preReaders[i]);
 
 				for (const auto& w : writers) {
@@ -195,7 +241,7 @@ namespace Ubpa::UECS::detail {
 
 			if (!postReaders.empty()) {
 				NoneGroup postGroup{ gMap.at(postReaders.front()) };
-				for (size_t i = 1; i < postReaders.size(); i++)
+				for (std::size_t i = 1; i < postReaders.size(); i++)
 					postGroup += gMap.at(postReaders[i]);
 
 				for (const auto& w : writers) {
@@ -220,13 +266,13 @@ namespace Ubpa::UECS::detail {
 
 			if (!preReaders.empty()) {
 				preGroup = gMap.at(preReaders.front());
-				for (size_t i = 1; i < preReaders.size(); i++)
+				for (std::size_t i = 1; i < preReaders.size(); i++)
 					preGroup += gMap.at(preReaders[i]);
 			}
 
 			if (!postReaders.empty()) {
 				postGroup = gMap.at(postReaders.front());
-				for (size_t i = 1; i < postReaders.size(); i++)
+				for (std::size_t i = 1; i < postReaders.size(); i++)
 					postGroup += gMap.at(postReaders[i]);
 			}
 
@@ -253,9 +299,9 @@ namespace Ubpa::UECS::detail {
 					rst.push_back(gMap.at(func));
 			}
 
-			for (size_t i = 0; i < rst.size(); i++) {
+			for (std::size_t i = 0; i < rst.size(); i++) {
 				auto& gi = rst[i];
-				for (size_t j = i + 1; j < rst.size(); j++) {
+				for (std::size_t j = i + 1; j < rst.size(); j++) {
 					const auto& gj = rst[j];
 					if (!NoneGroup::Parallelable(gi, gj))
 						continue;
@@ -286,20 +332,20 @@ namespace Ubpa::UECS::detail {
 }
 
 Schedule& Schedule::Order(string_view x, string_view y) {
-	sysFuncOrder.emplace(SystemFunc::HashCode(x), SystemFunc::HashCode(y));
+	sysFuncOrder.emplace(SystemFunc::GetValue(x), SystemFunc::GetValue(y));
 	return *this;
 }
 
-Schedule& Schedule::InsertNone(string_view sys, CmptType type) {
-	size_t hashcode = SystemFunc::HashCode(sys);
+Schedule& Schedule::InsertNone(string_view sys, TypeID type) {
+	std::size_t hashcode = SystemFunc::GetValue(sys);
 	auto& change = sysFilterChange[hashcode];
 	change.eraseNones.erase(type);
 	change.insertNones.insert(type);
 	return *this;
 }
 
-Schedule& Schedule::EraseNone(string_view sys, CmptType type) {
-	size_t hashcode = SystemFunc::HashCode(sys);
+Schedule& Schedule::EraseNone(string_view sys, TypeID type) {
+	std::size_t hashcode = SystemFunc::GetValue(sys);
 	auto& change = sysFilterChange[hashcode];
 	change.eraseNones.insert(type);
 	change.insertNones.erase(type);
@@ -307,18 +353,20 @@ Schedule& Schedule::EraseNone(string_view sys, CmptType type) {
 }
 
 void Schedule::Clear() {
-	for (const auto& [hash, sysFunc] : sysFuncs)
-		sysFuncPool.Recycle(sysFunc);
+	for (const auto& [hash, sysFunc] : sysFuncs) {
+		sysFunc->~SystemFunc();
+		sysFuncAllocator.deallocate(sysFunc, 1);
+	}
 	sysFuncs.clear();
 	sysFuncOrder.clear();
 	sysFilterChange.clear();
 	sysLockFilter.clear();
 }
 
-unordered_map<CmptType, Schedule::CmptSysFuncs> Schedule::GenCmptSysFuncsMap() const {
-	unordered_map<CmptType, CmptSysFuncs> rst;
+unordered_map<TypeID, Schedule::CmptSysFuncs> Schedule::GenCmptSysFuncsMap() const {
+	unordered_map<TypeID, CmptSysFuncs> rst;
 	for (const auto& [hashcode, sysFunc] : sysFuncs) {
-		for (const auto& type : sysFunc->entityQuery.locator.CmptAccessTypes()) {
+		for (const auto& type : sysFunc->entityQuery.locator.AccessTypeIDs()) {
 			switch (type.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -471,7 +519,7 @@ SysFuncGraph Schedule::GenSysFuncGraph() const {
 
 		auto sortedGroup = detail::Compiler::GenSortNoneGroup(graph, cmptSysFuncs, groupMap);
 		
-		for (size_t i = 0; i < sortedGroup.size() - 1; i++) {
+		for (std::size_t i = 0; i < sortedGroup.size() - 1; i++) {
 			const auto& gx = sortedGroup[i];
 			const auto& gy = sortedGroup[i + 1];
 			for (auto* fx : gx.sysFuncs) {
diff --git a/src/core/SingletonLocator.cpp b/src/core/SingletonLocator.cpp
index 100b0d9..3838aa4 100644
--- a/src/core/SingletonLocator.cpp
+++ b/src/core/SingletonLocator.cpp
@@ -3,7 +3,7 @@
 using namespace Ubpa::UECS;
 using namespace std;
 
-SingletonLocator::SingletonLocator(Span<const CmptAccessType> types) {
+SingletonLocator::SingletonLocator(std::span<const AccessTypeID> types) {
 	for (const auto& type : types)
 		singletonTypes.insert(type);
 }
diff --git a/src/core/SingletonsView.cpp b/src/core/SingletonsView.cpp
index aabb445..433b45b 100644
--- a/src/core/SingletonsView.cpp
+++ b/src/core/SingletonsView.cpp
@@ -2,7 +2,7 @@
 
 using namespace Ubpa::UECS;
 
-CmptAccessPtr SingletonsView::GetSingleton(CmptAccessType t) const noexcept {
+CmptAccessPtr SingletonsView::GetSingleton(AccessTypeID t) const noexcept {
 	for (const auto& singleton : singletons) {
 		if (singleton.AccessType() == t)
 			return singleton;
diff --git a/src/core/SysFuncGraph.cpp b/src/core/SysFuncGraph.cpp
index 1ad3caf..38ca00f 100644
--- a/src/core/SysFuncGraph.cpp
+++ b/src/core/SysFuncGraph.cpp
@@ -84,7 +84,7 @@ SysFuncGraph SysFuncGraph::SubGraph(const std::vector<SystemFunc*>& vertices) co
 }
 
 tuple<bool, vector<SystemFunc*>> SysFuncGraph::Toposort() const {
-	unordered_map<SystemFunc*, size_t> in_degree_map;
+	unordered_map<SystemFunc*, std::size_t> in_degree_map;
 
 	for (const auto& [parent, children] : adjList)
 		in_degree_map.emplace(parent, 0);
diff --git a/src/core/SystemFunc.cpp b/src/core/SystemFunc.cpp
index c5c0bd8..7add28d 100644
--- a/src/core/SystemFunc.cpp
+++ b/src/core/SystemFunc.cpp
@@ -2,7 +2,7 @@
 
 using namespace Ubpa::UECS;
 
-void SystemFunc::operator()(World* w, SingletonsView singletonsView, Entity e, size_t entityIndexInQuery, CmptsView cmptsView) const {
+void SystemFunc::operator()(World* w, SingletonsView singletonsView, Entity e, std::size_t entityIndexInQuery, CmptsView cmptsView) const {
 	assert(mode == Mode::Entity);
 	return func(
 		w,
@@ -14,7 +14,7 @@ void SystemFunc::operator()(World* w, SingletonsView singletonsView, Entity e, s
 	);
 }
 
-void SystemFunc::operator()(World* w, SingletonsView singletonsView, size_t entityBeginIndexInQuery, ChunkView chunkView) const {
+void SystemFunc::operator()(World* w, SingletonsView singletonsView, std::size_t entityBeginIndexInQuery, ChunkView chunkView) const {
 	assert(mode == Mode::Chunk);
 	return func(
 		w,
@@ -32,7 +32,7 @@ void SystemFunc::operator()(World* w, SingletonsView singletonsView) const {
 		w,
 		singletonsView,
 		Entity::Invalid(),
-		static_cast<size_t>(-1),
+		static_cast<std::size_t>(-1),
 		{},
 		{}
 	);
diff --git a/src/core/SystemMngr.cpp b/src/core/SystemMngr.cpp
index b9074af..464e245 100644
--- a/src/core/SystemMngr.cpp
+++ b/src/core/SystemMngr.cpp
@@ -34,14 +34,14 @@ void SystemMngr::Clear() {
 	aliveSystemIDs.clear();
 }
 
-void SystemMngr::Create(size_t ID) {
+void SystemMngr::Create(std::size_t ID) {
 	if (IsAlive(ID))
 		return;
 	systemTraits.Create(ID, w);
 	aliveSystemIDs.insert(ID);
 }
 
-void SystemMngr::Activate(size_t ID) {
+void SystemMngr::Activate(std::size_t ID) {
 	Create(ID);
 	if (IsActive(ID))
 		return;
@@ -49,19 +49,19 @@ void SystemMngr::Activate(size_t ID) {
 	activeSystemIDs.insert(ID);
 }
 
-void SystemMngr::Update(size_t ID, Schedule& schedule) const {
+void SystemMngr::Update(std::size_t ID, Schedule& schedule) const {
 	assert(IsActive(ID));
 	systemTraits.Update(ID, schedule);
 }
 
-void SystemMngr::Deactivate(size_t ID) {
+void SystemMngr::Deactivate(std::size_t ID) {
 	if (!IsAlive(ID) || !IsActive(ID))
 		return;
 	systemTraits.Deactivate(ID, w);
 	activeSystemIDs.erase(ID);
 }
 
-void SystemMngr::Destroy(size_t ID) {
+void SystemMngr::Destroy(std::size_t ID) {
 	if (!IsAlive(ID))
 		return;
 	Deactivate(ID);
@@ -69,10 +69,10 @@ void SystemMngr::Destroy(size_t ID) {
 	aliveSystemIDs.erase(ID);
 }
 
-bool SystemMngr::IsAlive(size_t ID) const {
+bool SystemMngr::IsAlive(std::size_t ID) const {
 	return aliveSystemIDs.find(ID) != aliveSystemIDs.end();
 }
 
-bool SystemMngr::IsActive(size_t ID) const {
+bool SystemMngr::IsActive(std::size_t ID) const {
 	return activeSystemIDs.find(ID) != activeSystemIDs.end();
 }
diff --git a/src/core/SystemTraits.cpp b/src/core/SystemTraits.cpp
index 0f892cd..3d8c83e 100644
--- a/src/core/SystemTraits.cpp
+++ b/src/core/SystemTraits.cpp
@@ -12,7 +12,7 @@ SystemTraits::SystemTraits(const SystemTraits& traits)
 	deactivateMap{ traits.deactivateMap },
 	destroyMap{ traits.destroyMap }
 {
-	for (size_t i = 0; i < names.size(); i++) {
+	for (std::size_t i = 0; i < names.size(); i++) {
 		const auto& name = names[i];
 		name2id.emplace(std::string_view{ name }, i);
 	}
@@ -25,95 +25,95 @@ SystemTraits& SystemTraits::operator=(SystemTraits& rhs) {
 	updateMap = rhs.updateMap;
 	deactivateMap = rhs.deactivateMap;
 	destroyMap = rhs.destroyMap;
-	for (size_t i = 0; i < names.size(); i++) {
+	for (std::size_t i = 0; i < names.size(); i++) {
 		const auto& name = names[i];
 		name2id.emplace(std::string_view{ name }, i);
 	}
 	return *this;
 }
 
-size_t SystemTraits::Register(std::string name) {
+std::size_t SystemTraits::Register(std::string name) {
 	assert(!name.empty());
 	
 	auto target = name2id.find(name);
 	if (target != name2id.end())
 		return target->second;
 
-	size_t idx = names.size();
+	std::size_t idx = names.size();
 	names.push_back(std::move(name));
 	name2id.emplace_hint(target, std::pair{ std::string_view{names[idx]}, idx });
 
 	return idx;
 }
 
-bool SystemTraits::IsRegistered(size_t ID) const noexcept {
+bool SystemTraits::IsRegistered(std::size_t ID) const noexcept {
 	return ID < names.size();
 }
 
-size_t SystemTraits::GetID(std::string_view name) const {
+std::size_t SystemTraits::GetID(std::string_view name) const {
 	auto target = name2id.find(name);
-	return target == name2id.end() ? static_cast<size_t>(-1) : target->second;
+	return target == name2id.end() ? static_cast<std::size_t>(-1) : target->second;
 }
 
-void SystemTraits::RegisterOnCreate(size_t ID, std::function<OnCreate> func) {
+void SystemTraits::RegisterOnCreate(std::size_t ID, std::function<OnCreate> func) {
 	assert(IsRegistered(ID));
 	createMap[ID] = std::move(func);
 }
 
-void SystemTraits::RegisterOnActivate(size_t ID, std::function<OnActivate> func) {
+void SystemTraits::RegisterOnActivate(std::size_t ID, std::function<OnActivate> func) {
 	assert(IsRegistered(ID));
 	activateMap[ID] = std::move(func);
 }
 
-void SystemTraits::RegisterOnUpdate(size_t ID, std::function<OnUpdate> func) {
+void SystemTraits::RegisterOnUpdate(std::size_t ID, std::function<OnUpdate> func) {
 	assert(IsRegistered(ID));
 	updateMap[ID] = std::move(func);
 }
 
-void SystemTraits::RegisterOnDeactivate(size_t ID, std::function<OnDeactivate> func) {
+void SystemTraits::RegisterOnDeactivate(std::size_t ID, std::function<OnDeactivate> func) {
 	assert(IsRegistered(ID));
 	deactivateMap[ID] = std::move(func);
 }
 
-void SystemTraits::RegisterOnDestroy(size_t ID, std::function<OnDestroy> func) {
+void SystemTraits::RegisterOnDestroy(std::size_t ID, std::function<OnDestroy> func) {
 	assert(IsRegistered(ID));
 	destroyMap[ID] = std::move(func);
 }
 
-std::string_view SystemTraits::Nameof(size_t ID) const noexcept {
+std::string_view SystemTraits::Nameof(std::size_t ID) const noexcept {
 	assert(ID < names.size());
 	return names[ID];
 }
 
-void SystemTraits::Create(size_t ID, World* w) const {
+void SystemTraits::Create(std::size_t ID, World* w) const {
 	assert(IsRegistered(ID));
 	auto target = createMap.find(ID);
 	if (target != createMap.end())
 		target->second(w);
 }
 
-void SystemTraits::Activate(size_t ID, World* w) const {
+void SystemTraits::Activate(std::size_t ID, World* w) const {
 	assert(IsRegistered(ID));
 	auto target = activateMap.find(ID);
 	if (target != activateMap.end())
 		target->second(w);
 }
 
-void SystemTraits::Update(size_t ID, Schedule& schedule) const {
+void SystemTraits::Update(std::size_t ID, Schedule& schedule) const {
 	assert(IsRegistered(ID));
 	auto target = updateMap.find(ID);
 	if (target != updateMap.end())
 		target->second(schedule);
 }
 
-void SystemTraits::Deactivate(size_t ID, World* w) const {
+void SystemTraits::Deactivate(std::size_t ID, World* w) const {
 	assert(IsRegistered(ID));
 	auto target = deactivateMap.find(ID);
 	if (target != deactivateMap.end())
 		target->second(w);
 }
 
-void SystemTraits::Destroy(size_t ID, World* w) const {
+void SystemTraits::Destroy(std::size_t ID, World* w) const {
 	assert(IsRegistered(ID));
 	auto target = destroyMap.find(ID);
 	if (target != destroyMap.end())
diff --git a/src/core/World.cpp b/src/core/World.cpp
index e1cb2ea..91f5b8a 100644
--- a/src/core/World.cpp
+++ b/src/core/World.cpp
@@ -10,12 +10,14 @@ using namespace std;
 
 World::World(const World& w)
 	:
+	jobRsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() },
 	systemMngr{ w.systemMngr, this },
 	entityMngr{ w.entityMngr }
 {}
 
 World::World(World&& w) noexcept
 	:
+	jobRsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() },
 	systemMngr{ std::move(w.systemMngr), this },
 	entityMngr{ std::move(w.entityMngr) }
 {}
@@ -28,8 +30,10 @@ void World::Update() {
 	inRunningJobGraph = true;
 
 	schedule.Clear();
-	for (auto* job : jobs)
-		jobPool.Recycle(job);
+	for (auto* job : jobs) {
+		job->~Taskflow();
+		jobRsrc->deallocate(job, sizeof(Job), alignof(Job));
+	}
 	jobs.clear();
 	jobGraph.clear();
 
@@ -51,7 +55,8 @@ void World::Update() {
 	unordered_map<SystemFunc*, JobHandle> table;
 
 	for (const auto& [func, adjVs] : graph.GetAdjList()) {
-		auto* job = jobPool.Request(func->Name());
+		auto* job_buffer = jobRsrc->allocate(sizeof(Job), alignof(Job));
+		auto* job = new(job_buffer)Job{ func->Name() };
 		jobs.push_back(job);
 		entityMngr.AutoGen(this, job, func);
 		table.emplace(func, jobGraph.composed_of(*job));
@@ -168,18 +173,18 @@ UGraphviz::Graph World::GenUpdateFrameGraph() const {
 		.RegisterGraphEdgeAttr("arrowhead", "curve")
 		.RegisterGraphEdgeAttr("arrowtail", "tee");
 
-	unordered_set<CmptType> cmptTypes;
-	unordered_set<CmptType> singletonTypes;
-	unordered_map<CmptType, size_t> cmptType2idx;
-	unordered_map<size_t, size_t> sysFuncHashcode2idx;
+	unordered_set<TypeID> cmptTypes;
+	unordered_set<TypeID> singletonTypes;
+	unordered_map<TypeID, std::size_t> cmptType2idx;
+	unordered_map<std::size_t, std::size_t> sysFuncHashcode2idx;
 
-	auto queryCmptName = [this](CmptType type) -> string {
+	auto queryCmptName = [this](TypeID type) -> string {
 		auto cmptName = entityMngr.cmptTraits.Nameof(type);
-		return cmptName.empty() ? std::to_string(type.HashCode()) : string{ cmptName };
+		return cmptName.empty() ? std::to_string(type.GetValue()) : string{ cmptName };
 	};
 
 	for (const auto& [hash, sysFunc] : schedule.sysFuncs) {
-		for (auto cmptType : sysFunc->entityQuery.locator.CmptAccessTypes())
+		for (auto cmptType : sysFunc->entityQuery.locator.AccessTypeIDs())
 			cmptTypes.insert(cmptType);
 		for (auto cmptType : sysFunc->entityQuery.filter.all)
 			cmptTypes.insert(cmptType);
@@ -209,8 +214,8 @@ UGraphviz::Graph World::GenUpdateFrameGraph() const {
 
 		subgraph_sys.AddNode(sysIdx);
 
-		for (const auto& cmptType : sysFunc->entityQuery.locator.CmptAccessTypes()) {
-			size_t edgeIdx;
+		for (const auto& cmptType : sysFunc->entityQuery.locator.AccessTypeIDs()) {
+			std::size_t edgeIdx;
 			switch (cmptType.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -234,7 +239,7 @@ UGraphviz::Graph World::GenUpdateFrameGraph() const {
 		const bool isChunk = sysFunc->GetMode() == SystemFunc::Mode::Chunk;
 
 		for (const auto& cmptType : sysFunc->entityQuery.filter.all) {
-			size_t edgeIdx;
+			std::size_t edgeIdx;
 			switch (cmptType.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -256,7 +261,7 @@ UGraphviz::Graph World::GenUpdateFrameGraph() const {
 		}
 
 		for (const auto& cmptType : sysFunc->entityQuery.filter.any) {
-			size_t edgeIdx;
+			std::size_t edgeIdx;
 			switch (cmptType.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -278,12 +283,12 @@ UGraphviz::Graph World::GenUpdateFrameGraph() const {
 		}
 
 		for (const auto& cmptType : sysFunc->entityQuery.filter.none) {
-			size_t edgeIdx = registry.RegisterEdge(sysIdx, cmptType2idx.at(cmptType));
+			std::size_t edgeIdx = registry.RegisterEdge(sysIdx, cmptType2idx.at(cmptType));
 			subgraph_none.AddEdge(edgeIdx);
 		}
 
 		for (const auto& cmptType : sysFunc->randomAccessor.types) {
-			size_t edgeIdx;
+			std::size_t edgeIdx;
 			switch (cmptType.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
diff --git a/src/test/03_query_entity/main.cpp b/src/test/03_query_entity/main.cpp
index df9735c..47aee11 100644
--- a/src/test/03_query_entity/main.cpp
+++ b/src/test/03_query_entity/main.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
@@ -15,7 +16,7 @@ struct MySystem {
 			[](World* w, Entity e, const A* a, const B* b) {
 				w->AddCommand(
 					[e, w]() {
-						if (!w->entityMngr.Have(e, CmptType::Of<C>)) {
+						if (!w->entityMngr.Have(e, TypeID_of<C>)) {
 							cout << "Attach C" << endl;
 							w->entityMngr.Attach<C>(e);
 						}
@@ -28,7 +29,7 @@ struct MySystem {
 			[](World* w, Entity e, const A* a, const B* b, const C* c) {
 				w->AddCommand(
 					[e, w]() {
-						if (w->entityMngr.Have(e, CmptType::Of<C>)) {
+						if (w->entityMngr.Have(e, TypeID_of<C>)) {
 							cout << "Dettach C" << endl;
 							w->entityMngr.Detach<C>(e);
 						}
diff --git a/src/test/04_filter/main.cpp b/src/test/04_filter/main.cpp
index 8caffc3..4879714 100644
--- a/src/test/04_filter/main.cpp
+++ b/src/test/04_filter/main.cpp
@@ -15,9 +15,9 @@ struct E { float val; };
 struct MySystem {
 	static void OnUpdate(Schedule& schedule) {
 		ArchetypeFilter filter;
-		filter.all = { CmptAccessType::Of<A> };
-		filter.any = { CmptAccessType::Of<B>, CmptAccessType::Of<C> };
-		filter.none = { CmptType::Of<D> };
+		filter.all = { AccessTypeID_of<A> };
+		filter.any = { AccessTypeID_of<B>, AccessTypeID_of<C> };
+		filter.none = { TypeID_of<D> };
 
 		schedule.RegisterEntityJob(
 			[](const E* e) {
diff --git a/src/test/06_none_parallel/main.cpp b/src/test/06_none_parallel/main.cpp
index 88a058a..76738ff 100644
--- a/src/test/06_none_parallel/main.cpp
+++ b/src/test/06_none_parallel/main.cpp
@@ -12,8 +12,8 @@ struct B {};
 struct MySystem {
 	static void OnUpdate(Schedule& schedule) {
 		ArchetypeFilter filter_w0, filter_w1;
-		filter_w0.none = { CmptType::Of<A> };
-		filter_w1.all = { CmptAccessType::Of<A> };
+		filter_w0.none = { TypeID_of<A> };
+		filter_w1.all = { AccessTypeID_of<A> };
 		schedule.RegisterEntityJob([](B*) {}, "need B, none A", true, filter_w0);
 		schedule.RegisterEntityJob([](B*) {}, "need A, B", true, filter_w1);;
 	}
diff --git a/src/test/07_overload/main.cpp b/src/test/07_overload/main.cpp
index fe3deea..81df181 100644
--- a/src/test/07_overload/main.cpp
+++ b/src/test/07_overload/main.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
@@ -18,7 +19,7 @@ struct VP_System {
 struct AVP_System {
 	static void OnUpdate(Schedule& schedule) {
 		schedule.RegisterEntityJob([](const A*, V*, P*) {cout << "AVP" << endl; }, "AVP");
-		schedule.InsertNone("VP", CmptType::Of<A>);
+		schedule.InsertNone("VP", TypeID_of<A>);
 	}
 };
 
diff --git a/src/test/08_job/main.cpp b/src/test/08_job/main.cpp
index e95cfe4..c4beba8 100644
--- a/src/test/08_job/main.cpp
+++ b/src/test/08_job/main.cpp
@@ -5,20 +5,20 @@
 using namespace Ubpa::UECS;
 using namespace std;
 
-struct Data { size_t value; };
+struct Data { std::size_t value; };
 
 struct MySystem {
 	static void OnUpdate(Schedule& schedule) {
-		auto buffer = std::make_shared<std::vector<size_t>>();
+		auto buffer = std::make_shared<std::vector<std::size_t>>();
 		auto f = schedule.RegisterEntityJob(
-			[buffer](size_t idxInQuery, const Data* data) {
+			[buffer](std::size_t idxInQuery, const Data* data) {
 				buffer->at(idxInQuery) = data->value;
 			},
 			"use"
 		);
 		schedule.RegisterJob([buffer]() {
-			size_t sum = 0;
-			for (size_t i : *buffer)
+			std::size_t sum = 0;
+			for (std::size_t i : *buffer)
 				sum += i;
 				cout << sum << endl;
 			},
@@ -26,7 +26,7 @@ struct MySystem {
 		);
 		schedule.RegisterJob(
 			[buffer, f](World* w) {
-				size_t num = w->entityMngr.EntityNum(f->entityQuery);
+				std::size_t num = w->entityMngr.EntityNum(f->entityQuery);
 				buffer->resize(num);
 			},
 			"allocate"
@@ -41,7 +41,7 @@ int main() {
 	World w;
 	w.systemMngr.RegisterAndActivate<MySystem>();
 
-	for (size_t i = 1; i <= 100; i++) {
+	for (std::size_t i = 1; i <= 100; i++) {
 		auto [e] = w.entityMngr.Create();
 		w.entityMngr.Emplace<Data>(e, i);
 	}
diff --git a/src/test/11_runtime_cmpt/main.cpp b/src/test/11_runtime_cmpt/main.cpp
index db1bfc1..8174c30 100644
--- a/src/test/11_runtime_cmpt/main.cpp
+++ b/src/test/11_runtime_cmpt/main.cpp
@@ -2,16 +2,17 @@
 
 #include <iostream>
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
 struct RTDSystem {
 	static void OnUpdate(Schedule& schedule) {
 		std::array cmpts_write = {
-			CmptAccessType{ "LuaCmpt", AccessMode::WRITE }
+			AccessTypeID{ "LuaCmpt", AccessMode::WRITE }
 		};
 		std::array cmpts_read = {
-			CmptAccessType{ "LuaCmpt", AccessMode::LATEST }
+			AccessTypeID{ "LuaCmpt", AccessMode::LATEST }
 		};
 
 		CmptLocator locator_write(cmpts_write);
@@ -19,7 +20,7 @@ struct RTDSystem {
 
 		schedule.RegisterEntityJob(
 			[](CmptsView cmpts) {
-				auto luaCmpt = cmpts.GetCmpt(CmptAccessType{ "LuaCmpt", AccessMode::WRITE });
+				auto luaCmpt = cmpts.GetCmpt(AccessTypeID{ "LuaCmpt", AccessMode::WRITE });
 				double& val = *reinterpret_cast<double*>(luaCmpt.Ptr());
 				val = 520.;
 			},
@@ -30,7 +31,7 @@ struct RTDSystem {
 		);
 		schedule.RegisterEntityJob(
 			[](CmptsView cmpts) {
-				auto luaCmpt = cmpts.GetCmpt(CmptAccessType{ "LuaCmpt", AccessMode::LATEST });
+				auto luaCmpt = cmpts.GetCmpt(AccessTypeID{ "LuaCmpt", AccessMode::LATEST });
 				const double& val = *reinterpret_cast<const double*>(luaCmpt.Ptr());
 				cout << "value : " << val << endl;
 			},
@@ -43,7 +44,7 @@ struct RTDSystem {
 };
 
 int main() {
-	CmptType type("LuaCmpt");
+	TypeID type("LuaCmpt");
 	// LuaCmpt {
 	//   number value;
     // }
diff --git a/src/test/12_framegraph/main.cpp b/src/test/12_framegraph/main.cpp
index 4e01690..790dc5a 100644
--- a/src/test/12_framegraph/main.cpp
+++ b/src/test/12_framegraph/main.cpp
@@ -17,9 +17,9 @@ struct G {};
 struct MySystem {
 	static void OnUpdate(Schedule& schedule) {
 		ArchetypeFilter filter;
-		filter.all = { CmptAccessType::Of<D> };
-		filter.any = { CmptAccessType::Of<E>, CmptAccessType::Of<F> };
-		filter.none = { CmptType::Of<G> };
+		filter.all = { AccessTypeID_of<D> };
+		filter.any = { AccessTypeID_of<E>, AccessTypeID_of<F> };
+		filter.none = { TypeID_of<G> };
 		schedule.RegisterEntityJob(
 			[](LastFrame<A> a, Write<B> b, Latest<C> c) {},
 			"System Func",
@@ -34,13 +34,13 @@ int main() {
 	w.systemMngr.RegisterAndActivate<MySystem>();
 
 	w.entityMngr.cmptTraits
-		.RegisterName(CmptType::Of<A>, "A")
-		.RegisterName(CmptType::Of<B>, "B")
-		.RegisterName(CmptType::Of<C>, "C")
-		.RegisterName(CmptType::Of<D>, "D")
-		.RegisterName(CmptType::Of<E>, "E")
-		.RegisterName(CmptType::Of<F>, "F")
-		.RegisterName(CmptType::Of<G>, "G")
+		.RegisterName(TypeID_of<A>, "A")
+		.RegisterName(TypeID_of<B>, "B")
+		.RegisterName(TypeID_of<C>, "C")
+		.RegisterName(TypeID_of<D>, "D")
+		.RegisterName(TypeID_of<E>, "E")
+		.RegisterName(TypeID_of<F>, "F")
+		.RegisterName(TypeID_of<G>, "G")
 		;
 
 	w.entityMngr.Create<A, B, C, D, E>();
diff --git a/src/test/13_performance/main.cpp b/src/test/13_performance/main.cpp
index 8c26d13..134459a 100644
--- a/src/test/13_performance/main.cpp
+++ b/src/test/13_performance/main.cpp
@@ -13,23 +13,23 @@ struct TestSystem {
 		schedule.RegisterEntityJob(
 			[](const A* a, B* b) {
 				// 256 floating-point operations
-				for (size_t i = 0; i < 256; i++)
+				for (std::size_t i = 0; i < 256; i++)
 					b->val *= a->val;
 			}, "TestSystem");
 	}
 };
 
 int main() {
-	size_t numEntities = 65536;
-	size_t numUpdate = 144 * 10;
+	std::size_t numEntities = 65536;
+	std::size_t numUpdate = 144 * 10;
 	World w;
 	w.systemMngr.RegisterAndActivate<TestSystem>();
 
 	auto t0 = std::chrono::steady_clock::now();
-	for (size_t i = 0; i < numEntities; i++)
+	for (std::size_t i = 0; i < numEntities; i++)
 		w.entityMngr.Create<A, B>();
 	auto t1 = std::chrono::steady_clock::now();
-	for (size_t i = 0; i < numUpdate; i++)
+	for (std::size_t i = 0; i < numUpdate; i++)
 		w.Update();
 	auto t2 = std::chrono::steady_clock::now();
 
diff --git a/src/test/14_serialize/main.cpp b/src/test/14_serialize/main.cpp
index 33cf2d7..50d16c9 100644
--- a/src/test/14_serialize/main.cpp
+++ b/src/test/14_serialize/main.cpp
@@ -10,14 +10,14 @@ struct Position { float val; };
 struct Velocity { float val; };
 
 class Dumper : public IListener {
-	size_t indent{ 0 };
+	std::size_t indent{ 0 };
 	bool firstSystem{ true };
 	bool firstEntity{ true };
 	bool firstCmpt{ true };
 	const World* w;
 
 	void PrintIndent() {
-		for (size_t i = 0; i < indent; i++)
+		for (std::size_t i = 0; i < indent; i++)
 			cout << "  ";
 	}
 
diff --git a/src/test/15_chunk_job/main.cpp b/src/test/15_chunk_job/main.cpp
index b496d71..9f0d1c5 100644
--- a/src/test/15_chunk_job/main.cpp
+++ b/src/test/15_chunk_job/main.cpp
@@ -15,8 +15,8 @@ constexpr float dt = 0.003f;
 struct SAB_System {
 	static void OnUpdate(Schedule& schedule) {
 		ArchetypeFilter filter;
-		filter.all = { CmptAccessType::Of<Write<S>> };
-		filter.any = { CmptAccessType::Of<Latest<A>>, CmptAccessType::Of<Latest<B>> };
+		filter.all = { AccessTypeID_of<Write<S>> };
+		filter.any = { AccessTypeID_of<Latest<A>>, AccessTypeID_of<Latest<B>> };
 
 		schedule.RegisterChunkJob([](ChunkView chunk) {
 			auto arrayS = chunk.GetCmptArray<S>();
@@ -28,19 +28,19 @@ struct SAB_System {
 
 			if (containsAB) {
 				cout << "[AB]" << endl;
-				for (size_t i = 0; i < chunk.EntityNum(); i++) {
+				for (std::size_t i = 0; i < chunk.EntityNum(); i++) {
 					arrayS[i].value += arrayA[i].value * arrayB[i].value;
 				}
 			}
 			else if (containsA) {
 				cout << "[A]" << endl;
-				for (size_t i = 0; i < chunk.EntityNum(); i++) {
+				for (std::size_t i = 0; i < chunk.EntityNum(); i++) {
 					arrayS[i].value += arrayA[i].value;
 				}
 			}
 			else { // containsB
 				cout << "[B]" << endl;
-				for (size_t i = 0; i < chunk.EntityNum(); i++) {
+				for (std::size_t i = 0; i < chunk.EntityNum(); i++) {
 					arrayS[i].value += arrayB[i].value;
 				}
 			}
diff --git a/src/test/17_serial/main.cpp b/src/test/17_serial/main.cpp
index 37973db..131ba15 100644
--- a/src/test/17_serial/main.cpp
+++ b/src/test/17_serial/main.cpp
@@ -34,12 +34,12 @@ int main() {
 	w.entityMngr.cmptTraits.Register
 		<A, B, C>();
 
-	for (size_t i = 0; i < 5; i++) {
+	for (std::size_t i = 0; i < 5; i++) {
 		w.Update();
 		std::cout << "^^^^^^^^^^" << std::endl;
 	}
 
-	for (size_t i = 0; i < 100; i++)
+	for (std::size_t i = 0; i < 100; i++)
 		w.entityMngr.Create();
 
 	w.RunEntityJob([](Entity e) {
diff --git a/src/test/19_direct_run/main.cpp b/src/test/19_direct_run/main.cpp
index 2b06ca7..c882cad 100644
--- a/src/test/19_direct_run/main.cpp
+++ b/src/test/19_direct_run/main.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
@@ -27,13 +28,13 @@ void print0(const World& w) {
 
 void print1(const World& w) {
 	ArchetypeFilter filter;
-	filter.all = { CmptAccessType::Of<Latest<Velocity>>, CmptAccessType::Of<Latest<Position>> };
+	filter.all = { AccessTypeID_of<Latest<Velocity>>, AccessTypeID_of<Latest<Position>> };
 	w.RunChunkJob(
 		[](const World* w, ChunkView chunk) {
 			auto velocities = chunk.GetCmptArray<Velocity>();
 			auto positions = chunk.GetCmptArray<Position>();
-			size_t N = chunk.EntityNum();
-			for (size_t i = 0; i < N; i++) {
+			std::size_t N = chunk.EntityNum();
+			for (std::size_t i = 0; i < N; i++) {
 				cout << velocities[i].val << ", " << positions[i].val << endl;
 			}
 		},
diff --git a/src/test/21_random/main.cpp b/src/test/21_random/main.cpp
index b0e360e..876e529 100644
--- a/src/test/21_random/main.cpp
+++ b/src/test/21_random/main.cpp
@@ -1,5 +1,6 @@
 #include <UECS/World.h>
 
+using namespace Ubpa;
 using namespace Ubpa::UECS;
 
 struct Translation { float value{ 0.f }; };
@@ -26,14 +27,14 @@ struct TranslationSystem {
 	static void OnUpdate(Schedule& schedule) {
 		{
 			ArchetypeFilter filter;
-			filter.all.insert(CmptType::Of<Parent>);
+			filter.all.insert(TypeID_of<Parent>);
 			schedule.RegisterEntityJob([](LocalToParent* l2p, const Translation* t) {
 				l2p->value = t->value;
 			}, "T2LocalToParent", true, filter);
 		}
 		{
 			ArchetypeFilter filter;
-			filter.none.insert(CmptType::Of<Parent>);
+			filter.none.insert(TypeID_of<Parent>);
 			schedule.RegisterEntityJob([](LocalToWorld* l2w, const Translation* t) {
 				l2w->value = t->value;
 			}, "T2LocalToWorld", true, filter);
@@ -42,11 +43,11 @@ struct TranslationSystem {
 			ArchetypeFilter filter;
 			RandomAccessor randomAccessor;
 			randomAccessor.types = {
-				CmptAccessType::Of<Write<LocalToWorld>>,
-				CmptAccessType::Of<Latest<LocalToParent>>,
-				CmptAccessType::Of<Latest<Children>>
+				AccessTypeID_of<Write<LocalToWorld>>,
+				AccessTypeID_of<Latest<LocalToParent>>,
+				AccessTypeID_of<Latest<Children>>
 			};
-			filter.none.insert(CmptType::Of<Parent>);
+			filter.none.insert(TypeID_of<Parent>);
 			schedule.RegisterEntityJob([](World* w, Children* children, const LocalToWorld* l2w) {
 				for(const auto& child : children->value)
 					SetTreeL2W(w, child, l2w);