Refactor folder structure

src/Runtime/Ghost.Core/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using Ghost.Core.Attributes;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Ghost.Graphics")]
+[assembly: InternalsVisibleTo("Ghost.Engine")]
+
+[assembly: EngineAssembly]

src/Runtime/Ghost.Core/Attributes/EngineAssemblyAttribute.cs

@@ -0,0 +1,6 @@
+namespace Ghost.Core.Attributes;
+
+[AttributeUsage(AttributeTargets.Assembly)]
+public sealed class EngineAssemblyAttribute : Attribute
+{
+}

src/Runtime/Ghost.Core/Contracts/ICloneable.cs

@@ -0,0 +1,11 @@
+namespace Ghost.Core.Contracts;
+
+public interface ICloneable
+{
+    object Clone();
+}
+
+public interface ICloneable<T>
+{
+    T Clone();
+}

src/Runtime/Ghost.Core/Contracts/IReleasable.cs

@@ -0,0 +1,6 @@
+namespace Ghost.Core.Contracts;
+
+internal interface IReleasable
+{
+    void InternalRelease();
+}

src/Runtime/Ghost.Core/Ghost.Core.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <DefineConstants>$(DefineConstants);PLATEFORME_WIN64</DefineConstants>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <DefineConstants>$(DefineConstants);PLATEFORME_WIN64</DefineConstants>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Misaki.HighPerformance" Version="1.0.4" />
+    <PackageReference Include="Misaki.HighPerformance.Jobs" Version="1.2.2" />
+    <PackageReference Include="Misaki.HighPerformance.LowLevel" Version="1.3.3" />
+    <PackageReference Include="Misaki.HighPerformance.Mathematics" Version="1.3.1" />
+    <PackageReference Include="System.IO.Hashing" Version="10.0.1" />
+    <PackageReference Include="TerraFX.Interop.Windows" Version="10.0.26100.6" />
+    <PackageReference Include="ZLinq" Version="1.5.4" />
+  </ItemGroup>
+
+</Project>

src/Runtime/Ghost.Core/Graphics/PipelineState.cs

@@ -0,0 +1,110 @@
+namespace Ghost.Core.Graphics;
+
+public enum ZTest : byte
+{
+    Disabled,
+    Less,
+    LessEqual,
+    Equal,
+    GreaterEqual,
+    Greater,
+    NotEqual,
+    Always
+}
+
+public enum ZWrite : byte
+{
+    Off,
+    On
+}
+
+public enum Cull : byte
+{
+    Off,
+    Front,
+    Back
+}
+
+public enum Blend : byte
+{
+    Opaque,
+    Alpha,
+    Additive,
+    Multiply,
+    PremultipliedAlpha
+}
+
+[Flags]
+public enum ColorWriteMask : byte
+{
+    None = 0,
+    Red = 1 << 0,
+    Green = 1 << 1,
+    Blue = 1 << 2,
+    Alpha = 1 << 3,
+    All = Red | Green | Blue | Alpha
+}
+
+public struct PipelineState
+{
+    public ZTest ZTest
+    {
+        get; set;
+    }
+
+    public ZWrite ZWrite
+    {
+        get; set;
+    }
+
+    public Cull Cull
+    {
+        get; set;
+    }
+
+    public Blend Blend
+    {
+        get; set;
+    }
+
+    public ColorWriteMask ColorMask
+    {
+        get; set;
+    }
+
+
+    public static PipelineState Default => new PipelineState
+    {
+        ZTest = ZTest.LessEqual,
+        ZWrite = ZWrite.On,
+        Cull = Cull.Back,
+        Blend = Blend.Opaque,
+        ColorMask = ColorWriteMask.All
+    };
+
+    public readonly ulong GetHashCode64()
+    {
+        // 32-bit packed key for states controlled by material / overrides.
+        // layout:
+        // 0..3   Blend (4 bits)
+        // 4..6   Cull  (3 bits)
+        // 7..10  DeafaultState (4 bits)
+        // 11     ZWrite (1 bit)
+        // 12..15 ColorMask (4 bits)
+
+        var key = 0u;
+        key |= ((uint)Blend & 0xFu) << 0;
+        key |= ((uint)Cull & 0x7u) << 4;
+        key |= ((uint)ZTest & 0xFu) << 7;
+        key |= ((uint)ZWrite & 0x1u) << 11;
+        key |= ((uint)ColorMask & 0xFu) << 12;
+
+        return key;
+    }
+
+    public override readonly int GetHashCode()
+    {
+        var code64 = GetHashCode64();
+        return ((int)code64) ^ (int)(code64 >> 32);
+    }
+}

src/Runtime/Ghost.Core/Graphics/ShaderDescriptor.cs

@@ -0,0 +1,108 @@
+namespace Ghost.Core.Graphics;
+
+public enum KeywordSpace
+{
+    Local,
+    Global,
+}
+
+public enum ShaderPropertyType
+{
+    None,
+    Float, Float2, Float3, Float4,
+    Float4x4,
+    Int, Int2, Int3, Int4,
+    UInt, UInt2, UInt3, UInt4,
+    Bool, Bool2, Bool3, Bool4,
+    Texture2D, Texture3D, TextureCube,
+    Texture2DArray, TextureCubeArray,
+    Sampler
+}
+
+public struct ShaderEntryPoint
+{
+    public string entry;
+    public string shader;
+
+    public readonly bool IsCreated => !string.IsNullOrEmpty(entry) && !string.IsNullOrEmpty(shader);
+}
+
+public struct KeywordsGroup
+{
+    public KeywordSpace space;
+    public List<string> keywords;
+}
+
+public struct PropertyDescriptor
+{
+    public string name;
+    public int offset;
+    public int size;
+    public ShaderPropertyType type;
+
+    public object? defaultValue;
+}
+
+public struct PassDescriptor
+{
+    public string identifier;
+    public string name;
+
+    public ShaderEntryPoint taskShader;
+    public ShaderEntryPoint meshShader;
+    public ShaderEntryPoint pixelShader;
+    public string[] defines;
+    public string[] includes;
+    public KeywordsGroup[] keywords;
+    public PipelineState localPipeline;
+    public string? hlsl;
+}
+
+public class ShaderDescriptor
+{
+    public string name = string.Empty;
+    public int cbufferSize;
+    public PropertyDescriptor[] globalProperties = null!;
+    public PropertyDescriptor[] properties = null!;
+    public PassDescriptor[] passes = null!;
+    public string? hlsl;
+}
+
+public static class ShaderDescriptorExtensions
+{
+    public static int GetSize(this ShaderPropertyType type)
+    {
+        return type switch
+        {
+            ShaderPropertyType.Float
+            or ShaderPropertyType.Int
+            or ShaderPropertyType.UInt
+            or ShaderPropertyType.Bool => 4,
+
+            ShaderPropertyType.Float2
+            or ShaderPropertyType.Int2
+            or ShaderPropertyType.UInt2
+            or ShaderPropertyType.Bool2 => 8,
+
+            ShaderPropertyType.Float3
+            or ShaderPropertyType.Int3
+            or ShaderPropertyType.UInt3
+            or ShaderPropertyType.Bool3 => 12,
+
+            ShaderPropertyType.Float4
+            or ShaderPropertyType.Int4
+            or ShaderPropertyType.UInt4
+            or ShaderPropertyType.Bool4 => 16,
+
+            ShaderPropertyType.Float4x4 => 64,
+
+            ShaderPropertyType.Texture2D
+            or ShaderPropertyType.Texture3D
+            or ShaderPropertyType.TextureCube
+            or ShaderPropertyType.Texture2DArray
+            or ShaderPropertyType.TextureCubeArray
+            or ShaderPropertyType.Sampler => 4, // Bindless resource use uint32
+            _ => 0,
+        };
+    }
+}

src/Runtime/Ghost.Core/Handle.cs

@@ -0,0 +1,242 @@
+namespace Ghost.Core;
+
+public readonly struct Handle<T> : IEquatable<Handle<T>>
+{
+    public int ID
+    {
+        get => field - 1;
+    }
+
+    public int Generation
+    {
+        get => field - 1;
+    }
+
+    public Handle(int id, int generation)
+    {
+        ID = id + 1;
+        Generation = generation + 1;
+    }
+
+    public static Handle<T> Invalid => default;
+
+    public readonly bool IsValid => this != Invalid;
+    public readonly bool IsInvalid => this == Invalid;
+
+    public readonly override int GetHashCode()
+    {
+        return ID + (Generation << 16);
+    }
+
+    public readonly override bool Equals(object? obj)
+    {
+        return obj is Handle<T> id && Equals(id);
+    }
+
+    public override string ToString()
+    {
+        return $"Handle<{typeof(T).Name}>({ID}, {Generation})";
+    }
+
+    public readonly bool Equals(Handle<T> other)
+    {
+        return ID == other.ID && Generation == other.Generation;
+    }
+
+    public readonly int CompareTo(Handle<T> other)
+    {
+        return ID.CompareTo(other.ID);
+    }
+
+    public static bool operator ==(Handle<T> a, Handle<T> b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Handle<T> a, Handle<T> b)
+    {
+        return !a.Equals(b);
+    }
+}
+
+public readonly struct Identifier<T> : IEquatable<Identifier<T>>
+{
+    public int Value
+    {
+        get => field - 1;
+    }
+
+    public Identifier(int value)
+    {
+        Value = value + 1;
+    }
+
+    public static Identifier<T> Invalid => default;
+
+    public readonly bool IsValid => this != Invalid;
+    public readonly bool IsInvalid => this == Invalid;
+
+    public readonly override int GetHashCode()
+    {
+        return Value;
+    }
+
+    public readonly override bool Equals(object? obj)
+    {
+        return obj is Identifier<T> id && Equals(id);
+    }
+
+    public override string ToString()
+    {
+        return $"Identifier<{typeof(T).Name}>({Value})";
+    }
+
+    public readonly bool Equals(Identifier<T> other)
+    {
+        return Value == other.Value;
+    }
+
+    public readonly int CompareTo(Identifier<T> other)
+    {
+        return Value.CompareTo(other.Value);
+    }
+
+    public static bool operator ==(Identifier<T> a, Identifier<T> b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Identifier<T> a, Identifier<T> b)
+    {
+        return !a.Equals(b);
+    }
+
+    public static bool operator <(Identifier<T> a, Identifier<T> b)
+    {
+        return a.Value < b.Value;
+    }
+
+    public static bool operator >(Identifier<T> a, Identifier<T> b)
+    {
+        return a.Value > b.Value;
+    }
+
+    public static bool operator <=(Identifier<T> a, Identifier<T> b)
+    {
+        return a.Value <= b.Value;
+    }
+
+    public static bool operator >=(Identifier<T> a, Identifier<T> b)
+    {
+        return a.Value >= b.Value;
+    }
+
+    public static implicit operator int(Identifier<T> id) => id.Value;
+    public static implicit operator Identifier<T>(int value) => new Identifier<T>(value);
+}
+
+public readonly struct Key64<T> : IEquatable<Key64<T>>
+{
+    public ulong Value
+    {
+        get;
+    }
+
+    public Key64(ulong value)
+    {
+        Value = value;
+    }
+
+    public static Key64<T> Invalid => new(0);
+
+    public bool IsValid => this != Invalid;
+    public bool IsInvalid => this == Invalid;
+
+    public readonly override int GetHashCode()
+    {
+        return Value.GetHashCode();
+    }
+
+    public readonly bool Equals(Key64<T> other)
+    {
+        return Value == other.Value;
+    }
+
+    public readonly int CompareTo(Key64<T> other)
+    {
+        return Value.CompareTo(other.Value);
+    }
+
+    public readonly override bool Equals(object? obj)
+    {
+        return obj is Key64<T> id && Equals(id);
+    }
+
+    public override string ToString()
+    {
+        return Value.ToString("X16");
+    }
+
+    public static bool operator ==(Key64<T> a, Key64<T> b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Key64<T> a, Key64<T> b)
+    {
+        return !a.Equals(b);
+    }
+}
+
+public readonly struct Key128<T> : IEquatable<Key128<T>>
+{
+    public UInt128 Value
+    {
+        get;
+    }
+
+    public Key128(UInt128 value)
+    {
+        Value = value;
+    }
+
+    public static Key128<T> Invalid => new(0);
+
+    public bool IsValid => this != Invalid;
+    public bool IsInvalid => this == Invalid;
+
+    public readonly override int GetHashCode()
+    {
+        return Value.GetHashCode();
+    }
+
+    public readonly bool Equals(Key128<T> other)
+    {
+        return Value == other.Value;
+    }
+
+    public readonly int CompareTo(Key128<T> other)
+    {
+        return Value.CompareTo(other.Value);
+    }
+
+    public readonly override bool Equals(object? obj)
+    {
+        return obj is Key128<T> id && Equals(id);
+    }
+
+    public override string ToString()
+    {
+        return Value.ToString("X16");
+    }
+
+    public static bool operator ==(Key128<T> a, Key128<T> b)
+    {
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Key128<T> a, Key128<T> b)
+    {
+        return !a.Equals(b);
+    }
+}

src/Runtime/Ghost.Core/Logging.cs

@@ -0,0 +1,214 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+
+namespace Ghost.Core;
+
+public enum LogLevel
+{
+    Info,
+    Warning,
+    Error
+}
+
+public readonly struct LogMessage
+{
+    public LogLevel Level
+    {
+        get;
+    }
+
+    public string Message
+    {
+        get;
+    }
+
+    public string? StackTrace
+    {
+        get;
+    }
+
+    public DateTime Timestamp
+    {
+        get;
+    }
+
+    public LogMessage(LogLevel level, string message, string? stackTrace = null)
+    {
+        Level = level;
+        Message = message;
+        StackTrace = stackTrace;
+        Timestamp = DateTime.Now;
+    }
+
+    public override string ToString()
+    {
+        if (StackTrace != null)
+        {
+            return $"{Timestamp:HH:mm:ss} [{Level}] {Message}\n{StackTrace}";
+        }
+
+        return $"{Timestamp:HH:mm:ss} [{Level}] {Message}";
+    }
+}
+
+public interface ILogger
+{
+    ReadOnlyObservableCollection<LogMessage> Logs
+    {
+        get;
+    }
+
+    void Log(string message, LogLevel level);
+    void Log(Exception exception);
+    void Assert(bool condition, string message);
+    void Clear();
+}
+
+public static class Logger
+{
+    // TODO: Add file logging.
+    private class LoggerImpl : ILogger
+    {
+        private readonly ObservableCollection<LogMessage> _logs = new();
+        private readonly ReadOnlyObservableCollection<LogMessage> _readOnly;
+        private readonly Lock _lock = new();
+
+        public ReadOnlyObservableCollection<LogMessage> Logs => _readOnly;
+
+        public LoggerImpl()
+        {
+            _readOnly = new ReadOnlyObservableCollection<LogMessage>(_logs);
+        }
+
+        [StackTraceHidden]
+        public void Log(string message, LogLevel level)
+        {
+            lock (_lock)
+            {
+                _logs.Add(new LogMessage(level, message));
+            }
+        }
+
+        [StackTraceHidden]
+        public void Log(Exception exception)
+        {
+            lock (_lock)
+            {
+                _logs.Add(new LogMessage(LogLevel.Error, exception.Message, exception.StackTrace));
+            }
+        }
+
+        [StackTraceHidden]
+        public void Assert(bool condition, string message)
+        {
+            lock (_lock)
+            {
+                if (!condition)
+                {
+                    Log(message, LogLevel.Error);
+                }
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_lock)
+            {
+                _logs.Clear();
+            }
+        }
+    }
+
+    private static readonly ILogger s_logger = new LoggerImpl();
+
+    public static ReadOnlyObservableCollection<LogMessage> Logs => s_logger.Logs;
+
+    [StackTraceHidden]
+    public static void Log(LogLevel level, object? message)
+    {
+        s_logger.Log(message?.ToString() ?? "null", level);
+    }
+
+    [StackTraceHidden]
+    public static void Log(LogLevel level, string message)
+    {
+        s_logger.Log(message, level);
+    }
+
+    [StackTraceHidden]
+    public static void Log(LogLevel level, string format, params object?[] args)
+    {
+        s_logger.Log(string.Format(format, args), level);
+    }
+
+    [StackTraceHidden]
+    public static void LogInfo(object? message)
+    {
+        s_logger.Log(message?.ToString() ?? "null", LogLevel.Info);
+    }
+
+    [StackTraceHidden]
+    public static void LogInfo(string message)
+    {
+        s_logger.Log(message, LogLevel.Info);
+    }
+
+    [StackTraceHidden]
+    public static void LogInfo(string format, params object?[] args)
+    {
+        s_logger.Log(string.Format(format, args), LogLevel.Info);
+    }
+
+    [StackTraceHidden]
+    public static void LogWarning(object? message)
+    {
+        s_logger.Log(message?.ToString() ?? "null", LogLevel.Warning);
+    }
+
+    [StackTraceHidden]
+    public static void LogWarning(string message)
+    {
+        s_logger.Log(message, LogLevel.Warning);
+    }
+
+    [StackTraceHidden]
+    public static void LogWarning(string format, params object?[] args)
+    {
+        s_logger.Log(string.Format(format, args), LogLevel.Warning);
+    }
+
+    [StackTraceHidden]
+    public static void LogError(object? message)
+    {
+        s_logger.Log(message?.ToString() ?? "null", LogLevel.Error);
+    }
+
+    [StackTraceHidden]
+    public static void LogError(string message)
+    {
+        s_logger.Log(message, LogLevel.Error);
+    }
+
+    [StackTraceHidden]
+    public static void LogError(string format, params object?[] args)
+    {
+        s_logger.Log(string.Format(format, args), LogLevel.Error);
+    }
+
+    [StackTraceHidden]
+    public static void LogError(Exception ex)
+    {
+        s_logger.Log(ex);
+    }
+
+    [StackTraceHidden]
+    public static void Assert(bool condition, string message)
+    {
+        s_logger.Assert(condition, message);
+    }
+
+    public static void Clear()
+    {
+        s_logger.Clear();
+    }
+}

src/Runtime/Ghost.Core/Result.cs

@@ -0,0 +1,407 @@
+using Misaki.HighPerformance.LowLevel;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core;
+
+public readonly struct Result
+{
+    private readonly string? _message;
+    private readonly bool _isSuccess;
+
+    public readonly string? Message => _message;
+    public readonly bool IsSuccess => _isSuccess;
+    public readonly bool IsFailure => !IsSuccess;
+
+    public Result(bool success, string? message = null)
+    {
+        _isSuccess = success;
+        _message = message;
+    }
+
+    public static Result Success()
+    {
+        return new Result(true);
+    }
+
+    public static Result Failure(string? message = null)
+    {
+        return new Result(false, message);
+    }
+
+    public static Result Failure(Error status)
+    {
+        return new Result(false, status.ToString());
+    }
+
+    public static Result<T> Success<T>(T value)
+    {
+        return Result<T>.Success(value);
+    }
+
+    public static Result<T> Failure<T>(string? message = null)
+    {
+        return Result<T>.Failure(message);
+    }
+
+    public static Result<T> Failure<T>(Error status)
+    {
+        return Result<T>.Failure(status.ToString());
+    }
+
+    public void Deconstruct(out bool success, out string? message)
+    {
+        success = IsSuccess;
+        message = Message;
+    }
+
+    public override string ToString() => IsSuccess ? "OK" : $"Error: {Message}";
+
+    public static implicit operator bool(Result result) => result.IsSuccess;
+}
+
+public readonly struct Result<T>
+{
+    private readonly T _value;
+    private readonly string? _message;
+    private readonly bool _isSuccess;
+
+    /// <summary>
+    /// Gets the value. Undefined if the result is a failure.
+    /// </summary>
+    public T Value
+    {
+        get
+        {
+#if DEBUG || GHOST_EDITOR
+            if (IsFailure)
+            {
+                throw new InvalidOperationException($"Cannot access Value when Result is a failure. {_message}");
+            }
+#endif
+            return _value;
+        }
+    }
+
+    public readonly string? Message => _message;
+    public readonly bool IsSuccess => _isSuccess;
+    public readonly bool IsFailure => !IsSuccess;
+
+    public Result(bool success, T value, string? message = null)
+    {
+        _isSuccess = success;
+        _value = value;
+        _message = message;
+    }
+
+    public static Result<T> Success(T value)
+    {
+        return new Result<T>(true, value);
+    }
+
+    public static Result<T> Failure(string? message = null)
+    {
+        return new Result<T>(false, default!, message);
+    }
+
+    public void Deconstruct(out bool success, out T value, out string? message)
+    {
+        success = IsSuccess;
+        value = Value;
+        message = Message;
+    }
+
+    public override string ToString() => IsSuccess ? $"OK: {Value}" : $"Error: {Message}";
+
+    public static implicit operator Result<T>(T? data) => data is not null ? Success(data) : Failure(null);
+    public static implicit operator Result<T>(Result result) => result.IsSuccess ? Success(default!) : Failure(result.Message);
+    public static implicit operator bool(Result<T> result) => result.IsSuccess;
+}
+
+public enum Error : byte
+{
+    None,
+    NotFound,
+    InvalidArgument,
+    InvalidState,
+    InternalError,
+    PermissionDenied,
+    NotSupported,
+    OutOfMemory,
+    Timeout,
+    Cancelled,
+    UnknownError,
+
+    Success = None,
+}
+
+public readonly struct Result<T, E>
+    where E : struct, Enum
+{
+    private readonly T _value;
+    private readonly E _error;
+
+    /// <summary>
+    /// Gets the value. Undefined if the result is a failure.
+    /// </summary>
+    public T Value
+    {
+        get
+        {
+#if DEBUG || GHOST_EDITOR
+            if (IsFailure)
+            {
+                throw new InvalidOperationException($"Cannot access Value when Result is a failure. Error: {_error}");
+            }
+#endif
+            return _value;
+        }
+    }
+
+    public E Error => _error;
+    public bool IsSuccess => EqualityComparer<E>.Default.Equals(_error, default);
+    public bool IsFailure => !IsSuccess;
+
+    public Result(T value, E status)
+    {
+        _value = value;
+        _error = status;
+    }
+
+    public static Result<T, E> Success(T value)
+    {
+        return new Result<T, E>(value, default);
+    }
+
+    public static Result<T, E> Failure(E status)
+    {
+        return new Result<T, E>(default!, status);
+    }
+
+    public void Deconstruct(out T value, out E status)
+    {
+        value = Value;
+        status = Error;
+    }
+
+    public override string ToString() => $"Value: {_value}, Status: {_error}";
+
+    public static implicit operator Result<T, E>(T data) => new(data, default);
+    public static implicit operator Result<T, E>(E status) => new(default!, status);
+    public static implicit operator bool(Result<T, E> result) => result.IsSuccess;
+}
+
+public readonly ref struct RefResult<T, E>
+    where E : struct, Enum
+{
+    private readonly ref T _value;
+    private readonly E  _error;
+
+    /// <summary>
+    /// Gets a reference to the value. Undefined if the result is a failure.
+    /// </summary>
+    public ref T Value
+    {
+        get
+        {
+#if DEBUG || GHOST_EDITOR
+            if (IsFailure)
+            {
+                throw new InvalidOperationException($"Cannot access Value when Result is a failure. Error: {_error}");
+            }
+#endif
+            return ref _value;
+        }
+    }
+
+    public E Error => _error;
+    public bool IsSuccess => EqualityComparer<E>.Default.Equals(_error, default);
+    public bool IsFailure => !IsSuccess;
+
+    public RefResult(ref T value, E error)
+    {
+        _value = ref value;
+        _error = error;
+    }
+
+    public static RefResult<T, E> Success(ref T value)
+    {
+        return new RefResult<T, E>(ref value, default);
+    }
+
+    public static RefResult<T, E> Failure(E error)
+    {
+        return new RefResult<T, E>(ref Unsafe.NullRef<T>(), error);
+    }
+
+    public void Deconstruct(out bool success, out Ref<T> value, out E status)
+    {
+        success = IsSuccess;
+        value = new Ref<T>(ref Value);
+        status = Error;
+    }
+
+    public override string ToString() => $"Value: {_value}, Status: {_error}";
+
+    public static implicit operator RefResult<T, E>(Ref<T> data) => new(ref data.Get(), default);
+    public static implicit operator RefResult<T, E>(E error) => new(ref Unsafe.NullRef<T>(), error);
+    public static implicit operator bool(RefResult<T, E> result) => result.IsSuccess;
+}
+
+public static class ResultExtensions
+{
+    public static void ThrowIfFailed(this Error result, [CallerArgumentExpression(nameof(result))] string? op = null)
+    {
+        if (result != Error.None)
+        {
+            throw new InvalidOperationException($"{op} failed: {result}");
+        }
+    }
+
+    public static void ThrowIfFailed(this Result result, [CallerArgumentExpression(nameof(result))] string? op = null)
+    {
+        if (!result.IsSuccess)
+        {
+            throw new InvalidOperationException($"{op} failed: {result.Message}");
+        }
+    }
+
+    public static T GetValueOrThrow<T>(this Result<T> result, [CallerArgumentExpression(nameof(result))] string? op = null)
+    {
+        if (!result.IsSuccess)
+        {
+            throw new InvalidOperationException($"{op} failed: {result.Message}");
+        }
+
+        return result.Value;
+    }
+
+    public static T GetValueOrThrow<T, S>(this Result<T, S> result, [CallerArgumentExpression(nameof(result))] string? op = null)
+        where S : struct, Enum
+    {
+        if (!result.IsSuccess)
+        {
+            throw new InvalidOperationException($"{op} failed: status {result.Error}");
+        }
+
+        return result.Value;
+    }
+
+    public static T? GetValueOrDefault<T>(this Result<T> result, T? defaultValue = default)
+    {
+        return result.IsSuccess ? result.Value : defaultValue;
+    }
+
+    public static T? GetValueOrDefault<T, S>(this Result<T, S> result, T? defaultValue = default)
+        where S : struct, Enum
+    {
+        return result.IsSuccess ? result.Value : defaultValue;
+    }
+
+    public static bool TryGetValue<T>(this Result<T> result, out T value)
+    {
+        if (result.IsSuccess)
+        {
+            value = result.Value;
+            return true;
+        }
+
+        value = default!;
+        return false;
+    }
+
+    public static bool TryGetValue<T, S>(this Result<T, S> result, out T value)
+        where S : struct, Enum
+    {
+        if (result.IsSuccess)
+        {
+            value = result.Value;
+            return true;
+        }
+
+        value = default!;
+        return false;
+    }
+
+    public static Result OnSuccess(this Result result, Action action)
+    {
+        if (result.IsSuccess)
+        {
+            action();
+        }
+
+        return result;
+    }
+
+    public static Result<T> OnSuccess<T>(this Result<T> result, Action<T> action)
+    {
+        if (result.IsSuccess)
+        {
+            action(result.Value);
+        }
+
+        return result;
+    }
+
+    public static Result<T, E> OnSuccess<T, E>(this Result<T, E> result, Action<T> action)
+        where E : struct, Enum
+    {
+        if (result.IsSuccess)
+        {
+            action(result.Value);
+        }
+
+        return result;
+    }
+
+    public static Result OnFailed(this Result result, Action<string?> action)
+    {
+        if (result.IsFailure)
+        {
+            action(result.Message);
+        }
+
+        return result;
+    }
+
+    public static Result<T> OnFailed<T>(this Result<T> result, Action<string?> action)
+    {
+        if (result.IsFailure)
+        {
+            action(result.Message);
+        }
+
+        return result;
+    }
+
+    public static Result<T, E> OnFailed<T, E>(this Result<T, E> result, Action<E> action)
+        where E : struct, Enum
+    {
+        if (result.IsFailure)
+        {
+            action(result.Error);
+        }
+
+        return result;
+    }
+
+    public static Result<U> Then<T, U>(this Result<T> result, Func<T, Result<U>> func)
+    {
+        if (result.IsFailure)
+        {
+            return Result<U>.Failure(result.Message);
+        }
+
+        return func(result.Value);
+    }
+
+    public static Result<U, E> Then<T, U, E>(this Result<T, E> result, Func<T, Result<U, E>> func)
+        where E : struct, Enum
+    {
+        if (result.IsFailure)
+        {
+            return Result<U, E>.Failure(result.Error);
+        }
+
+        return func(result.Value);
+    }
+}

src/Runtime/Ghost.Core/TypeHandle.cs

@@ -0,0 +1,67 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core;
+
+public readonly struct TypeHandle
+{
+    public readonly IntPtr Value
+    {
+        get;
+    }
+
+    private TypeHandle(IntPtr value)
+    {
+        Value = value;
+    }
+
+    /// <summary>
+    /// Gets the space handle for the specified space.
+    /// </summary>
+    /// <param name="type">The space to get the handle for.</param>
+    /// <returns>The space handle as a nint.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TypeHandle Get(Type type) => new TypeHandle(type.TypeHandle.Value);
+
+    /// <summary>
+    /// Gets the space handle for the specified space.
+    /// </summary>
+    /// <typeparam name="T">The space to get the handle for.</typeparam>
+    /// <returns>The space handle as a nint.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TypeHandle Get<T>() => Get(typeof(T));
+
+    /// <summary>
+    /// Converts a TypeHandle to a Type.
+    /// </summary>
+    /// <param name="handle">The TypeHandle to convert.</param>
+    /// <returns>The corresponding Type.</returns>
+    public Type? ToType()
+    {
+        return Type.GetTypeFromHandle(RuntimeTypeHandle.FromIntPtr(Value));
+    }
+
+    public override int GetHashCode()
+    {
+        return Value.GetHashCode();
+    }
+
+    public static implicit operator TypeHandle(IntPtr value)
+    {
+        return new TypeHandle(value);
+    }
+
+    public static implicit operator IntPtr(TypeHandle handle)
+    {
+        return handle.Value;
+    }
+
+    public static implicit operator TypeHandle(Type type)
+    {
+        return Get(type);
+    }
+
+    public static implicit operator Type?(TypeHandle handle)
+    {
+        return handle.ToType();
+    }
+}

src/Runtime/Ghost.Core/Utilities/BinaryReader.cs

@@ -0,0 +1,36 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core.Utilities;
+
+public ref struct BinaryReader
+{
+    private readonly Span<byte> _buffer;
+    private int _position;
+
+    public int Position
+    {
+        readonly get => _position;
+        set => _position = value;
+    }
+
+    public BinaryReader(Span<byte> buffer)
+    {
+        _buffer = buffer;
+        _position = 0;
+    }
+
+    public T Read<T>()
+        where T : unmanaged
+    {
+        var value = Unsafe.ReadUnaligned<T>(ref _buffer[_position]);
+        _position += Unsafe.SizeOf<T>();
+        return value;
+    }
+
+    public ReadOnlySpan<byte> ReadBytes(int length)
+    {
+        var span = _buffer.Slice(_position, length);
+        _position += length;
+        return span;
+    }
+}

src/Runtime/Ghost.Core/Utilities/BinaryWriter.cs

@@ -0,0 +1,41 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core.Utilities;
+
+public ref struct BinaryWriter
+{
+    private readonly Span<byte> _buffer;
+    private int _position;
+
+    public int Position
+    {
+        readonly get => _position;
+        set => _position = value;
+    }
+
+    public BinaryWriter(Span<byte> buffer)
+    {
+        _buffer = buffer;
+        _position = 0;
+    }
+
+    public unsafe void Write<T>(scoped ref readonly T value)
+        where T : unmanaged
+    {
+        Unsafe.WriteUnaligned(ref _buffer[_position], value);
+        _position += sizeof(T);
+    }
+
+    public void WriteBytes(ReadOnlySpan<byte> data)
+    {
+        data.CopyTo(_buffer.Slice(_position, data.Length));
+        _position += data.Length;
+    }
+
+    public Span<byte> GetSpan(int length)
+    {
+        var span = _buffer.Slice(_position, length);
+        _position += length;
+        return span;
+    }
+}

src/Runtime/Ghost.Core/Utilities/CollectionPool.cs

@@ -0,0 +1,25 @@
+using Misaki.HighPerformance.Buffer;
+
+namespace Ghost.Core.Utilities;
+
+public class CollectionPool<TCollection, TItem>
+    where TCollection : class, ICollection<TItem>, new()
+{
+    internal static readonly ObjectPool<TCollection> s_pool = new ObjectPool<TCollection>(() => new TCollection(), null, 1);
+
+    public static TCollection Rent()
+    {
+        return s_pool.Rent();
+    }
+
+    public static void Return(TCollection collection)
+    {
+        collection.Clear();
+        s_pool.Return(collection);
+    }
+}
+
+public class ListPool<T> : CollectionPool<List<T>, T>;
+public class HashSetPool<T> : CollectionPool<HashSet<T>, T>;
+public class DictionaryPool<TKey, TValue> : CollectionPool<Dictionary<TKey, TValue>, KeyValuePair<TKey, TValue>>
+    where TKey : notnull;

src/Runtime/Ghost.Core/Utilities/EnumUtility.cs

@@ -0,0 +1,9 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Ghost.Core.Utilities;
+
+internal class EnumUtility
+{
+}

src/Runtime/Ghost.Core/Utilities/Hash.cs

@@ -0,0 +1,44 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Core.Utilities;
+
+public static class Hash
+{
+    private const ulong _PRIME1 = 0xfa517d6985796b7bul;
+    private const ulong _PRIME2 = 0x589578278297b985ul;
+    private const ulong _PRIME3 = 0x221147a447814b73ul;
+    private const ulong _PRIME4 = 0x9e3779b97f4a7c15ul; // Golden Ratio
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong Hash64(ulong a, ulong b)
+    {
+        return a ^ (b * _PRIME4 + (a << 6) + (a >> 2));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong Hash64(ulong a, ulong b, ulong c)
+    {
+        ulong h1 = a * _PRIME1;
+        ulong h2 = b * _PRIME2;
+        ulong h3 = c * _PRIME3;
+
+        ulong h = h1 ^ h2 ^ h3;
+
+        h = (h ^ (h >> 33)) * _PRIME4;
+        return h ^ (h >> 29);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong Hash64(ulong a, ulong b, ulong c, ulong d)
+    {
+        ulong h1 = a * _PRIME1;
+        ulong h2 = b * _PRIME2;
+        ulong h3 = c * _PRIME3;
+        ulong h4 = d * _PRIME4;
+
+        ulong h = h1 ^ h2 ^ h3 ^ h4;
+
+        h = (h ^ (h >> 33)) * _PRIME1;
+        return h ^ (h >> 29);
+    }
+}

src/Runtime/Ghost.Core/Utilities/InternalResource.cs

@@ -0,0 +1,12 @@
+using Ghost.Core.Contracts;
+
+namespace Ghost.Core.Utilities;
+
+internal static class InternalResource
+{
+    public static void Release<T>(ref T? resource)
+        where T : IReleasable
+    {
+        resource?.InternalRelease();
+    }
+}

src/Runtime/Ghost.Core/Utilities/Win32Utility.cs

@@ -0,0 +1,115 @@
+using Misaki.HighPerformance.LowLevel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Versioning;
+using TerraFX.Interop.Windows;
+
+namespace Ghost.Core.Utilities;
+
+[SupportedOSPlatform("windows10.0.19041.0")]
+internal static unsafe partial class Win32Utility
+{
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public readonly ref struct IID_PPV
+    {
+        public readonly Guid* iid;
+        public readonly void** ppv;
+
+        public IID_PPV(Guid* iid, void** ppv)
+        {
+            this.iid = iid;
+            this.ppv = ppv;
+        }
+
+        public void Deconstruct(out Guid* iid, out void** ppv)
+        {
+            iid = this.iid;
+            ppv = this.ppv;
+        }
+    }
+
+    public static Guid* IID_NULL
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID.IID_NULL));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IID_PPV IID_PPV_ARGS<T>(ComPtr<T>* comPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        return new IID_PPV(Windows.__uuidof<T>(), (void**)comPtr);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Attach<T>(ref this UniquePtr<T> uPtr, T* other)
+        where T : unmanaged, IUnknown.Interface
+    {
+        var ptr = uPtr.Get();
+        if (ptr != null)
+        {
+            var refCount = ptr->Release();
+            Debug.Assert((refCount != 0) || (ptr != other));
+        }
+
+        uPtr = new UniquePtr<T>(other);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Dispose<T>(ref this UniquePtr<T> uPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        var ptr = uPtr.Detach();
+        if (ptr != null)
+        {
+            ptr->Release();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result ToResult(this HRESULT hr, [CallerArgumentExpression(nameof(hr))] string? op = null)
+    {
+        if (hr.SUCCEEDED)
+        {
+            return Result.Success();
+        }
+
+        return Result.Failure($"{op} failed with code {hr}");
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void** ReleaseAndGetVoidAddressOf<T>(ref this ComPtr<T> comPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        return (void**)comPtr.ReleaseAndGetAddressOf();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ComPtr<T> Move<T>(ref this ComPtr<T> comPtr)
+        where T : unmanaged, IUnknown.Interface
+    {
+        var copy = default(ComPtr<T>);
+        comPtr.Swap(ref copy);
+        return copy;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool HasFlag<T>(this uint flags, T flag)
+        where T : Enum
+    {
+        return (flags & Unsafe.As<T, uint>(ref flag)) != 0;
+    }
+
+    extension(MemoryLeakException)
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowIfRefCountNonZero(uint count)
+        {
+            if (count != 0)
+            {
+                throw new MemoryLeakException($"Reference count is not zero: {count}");
+            }
+        }
+    }
+}

src/Runtime/Ghost.Engine/ActivationHandler.cs

@@ -0,0 +1,11 @@
+using Ghost.Engine.Models;
+
+namespace Ghost.Engine;
+
+internal static class ActivationHandler
+{
+    public static void Handle(LaunchArgument args)
+    {
+
+    }
+}

src/Runtime/Ghost.Engine/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using Ghost.Core.Attributes;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Ghost.Editor")]
+[assembly: InternalsVisibleTo("Ghost.Editor.Core")]
+
+[assembly: EngineAssembly]

src/Runtime/Ghost.Engine/Components/Hierarchy.cs

@@ -0,0 +1,24 @@
+using Ghost.Engine.Editor;
+using Ghost.Entities;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Engine.Components;
+
+[HideEditor]
+public struct Hierarchy : IComponent
+{
+    public Entity parent;
+    public Entity firstChild;
+    public Entity nextSibling;
+
+    public static Hierarchy Root
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new()
+        {
+            parent = Entity.Invalid,
+            firstChild = Entity.Invalid,
+            nextSibling = Entity.Invalid
+        };
+    }
+}

src/Runtime/Ghost.Engine/Components/LocalToWorld.cs

@@ -0,0 +1,9 @@
+using Ghost.Entities;
+using Misaki.HighPerformance.Mathematics;
+
+namespace Ghost.Engine.Components;
+
+public struct LocalToWorld : IComponent
+{
+    public float4x4 matrix;
+}

src/Runtime/Ghost.Engine/Components/SceneID.cs

@@ -0,0 +1,9 @@
+using Ghost.Engine.Core;
+using Ghost.Entities;
+
+namespace Ghost.Engine.Components;
+
+public struct SceneID : IComponent // TODO: ISharedComponent
+{
+    public Scene scene;
+}

src/Runtime/Ghost.Engine/Core/Scene.cs

@@ -0,0 +1,154 @@
+using Ghost.Entities;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Ghost.Engine.Core;
+
+/// <summary>
+/// Represents a runtime scene - a collection of entities with the same SceneID.
+/// </summary>
+public readonly struct Scene : IEquatable<Scene>
+{
+    private readonly short _id;
+
+    /// <summary>
+    /// Gets the unique identifier of this scene.
+    /// </summary>
+    public short ID => _id;
+
+    /// <summary>
+    /// Gets whether this scene is valid.
+    /// </summary>
+    public bool IsValid => _id >= 0;
+
+    /// <summary>
+    /// Gets an invalid scene instance.
+    /// </summary>
+    public static Scene Invalid => new(-1);
+
+    internal Scene(short id)
+    {
+        _id = id;
+    }
+
+    public bool Equals(Scene other)
+    {
+        return _id == other._id;
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is Scene other && Equals(other);
+    }
+
+    public override int GetHashCode()
+    {
+        return _id.GetHashCode();
+    }
+
+    public static bool operator ==(Scene left, Scene right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Scene left, Scene right)
+    {
+        return !left.Equals(right);
+    }
+
+    public override string ToString()
+    {
+        return $"Scene(ID: {_id})";
+    }
+}
+
+/// <summary>
+/// Manages scenes within a world.
+/// </summary>
+/// <remarks>
+/// This is a minimal runtime representation. All metadata (like scene names) 
+/// should be stored in editor-only classes (SceneNode).
+/// </remarks>
+public static class SceneManager
+{
+    private static short s_nextSceneID;
+    private static readonly Queue<short> s_recycledSceneIDs = new();
+
+    /// <summary>
+    /// Creates a new scene in the world.
+    /// </summary>
+    /// <returns>The created scene.</returns>
+    public static Scene CreateScene()
+    {
+        if (!s_recycledSceneIDs.TryDequeue(out var id))
+        {
+            id = s_nextSceneID++;
+        }
+
+        return new Scene(id);
+    }
+
+    /// <summary>
+    /// Destroys all entities belonging to the specified scene.
+    /// </summary>
+    /// <param name="scene">The scene to unload.</param>
+    /// <param name="world">The world containing the entities.</param>
+    public static void UnloadScene(Scene scene, World world)
+    {
+        var queryID = new QueryBuilder().WithAll<Components.SceneID>().Build(world);
+        ref var query = ref world.ComponentManager.GetEntityQueryReference(queryID);
+
+        using var scope = AllocationManager.CreateStackScope();
+        var entitiesToDestroy = new UnsafeList<Entity>(128, scope.AllocationHandle);
+
+        // Iterate through all matching entities
+        foreach (var chunk in query.GetChunkIterator())
+        {
+            var entities = chunk.GetEntities();
+            var sceneIDs = chunk.GetComponentData<Components.SceneID>();
+
+            for (var i = 0; i < chunk.Count; i++)
+            {
+                if (sceneIDs[i].scene.ID == scene.ID)
+                {
+                    entitiesToDestroy.Add(entities[i]);
+                }
+            }
+        }
+
+        world.EntityManager.DestroyEntities(entitiesToDestroy.AsSpan());
+        s_recycledSceneIDs.Enqueue(scene.ID);
+    }
+
+    /// <summary>
+    /// Gets all entities belonging to the specified scene.
+    /// </summary>
+    /// <param name="scene">The scene to query.</param>
+    /// <param name="world">The world containing the entities.</param>
+    /// <param name="entities">Span to store the entities.</param>
+    /// <returns>The number of entities written to the span.</returns>
+    public static UnsafeList<Entity> GetSceneEntities(Scene scene, World world, AllocationHandle handle)
+    {
+        var queryID = new QueryBuilder().WithAll<Components.SceneID>().Build(world);
+        ref var query = ref world.ComponentManager.GetEntityQueryReference(queryID);
+
+        var entities = new UnsafeList<Entity>(128, handle);
+
+        // Iterate through all matching entities
+        foreach (var chunk in query.GetChunkIterator())
+        {
+            var chunkEntities = chunk.GetEntities();
+            var sceneIDs = chunk.GetComponentData<Components.SceneID>();
+
+            for (var i = 0; i < chunk.Count; i++)
+            {
+                if (sceneIDs[i].scene.ID == scene.ID)
+                {
+                    entities.Add(chunkEntities[i]);
+                }
+            }
+        }
+
+        return entities;
+    }
+}

src/Runtime/Ghost.Engine/Editor/HideEditorAttribute.cs

@@ -0,0 +1,6 @@
+namespace Ghost.Engine.Editor;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
+public class HideEditorAttribute : Attribute
+{
+}

src/Runtime/Ghost.Engine/EngineCore.cs

@@ -0,0 +1,38 @@
+using Ghost.Entities;
+using Misaki.HighPerformance.Jobs;
+
+namespace Ghost.Engine;
+
+public interface IEngineContext : IDisposable
+{
+    JobScheduler JobScheduler { get; }
+}
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+internal class EngineEntryAttribute : Attribute
+{
+}
+
+[EngineEntry]
+internal sealed partial class EngineCore : IEngineContext
+{
+    private readonly JobScheduler _jobScheduler;
+
+    public JobScheduler JobScheduler => _jobScheduler;
+
+    public EngineCore()
+    {
+        _jobScheduler = new JobScheduler(Environment.ProcessorCount - 2); // We -2 here, one for main thread, one for render thread
+
+        ComponentRegistry.GetOrRegisterComponentID<ManagedEntityRef>();
+    }
+
+    public void Init()
+    {
+    }
+
+    public void Dispose()
+    {
+        _jobScheduler.Dispose();
+    }
+}

src/Runtime/Ghost.Engine/Ghost.Engine.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Services\**" />
+    <EmbeddedResource Remove="Services\**" />
+    <None Remove="Services\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Ghost.Core\Ghost.Core.csproj" />
+    <ProjectReference Include="..\Ghost.Entities\Ghost.Entities.csproj" />
+    <!--<ProjectReference Include="..\Ghost.Generator\Ghost.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />-->
+    <ProjectReference Include="..\Ghost.Graphics\Ghost.Graphics.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MemoryPack" Version="1.21.4" />
+  </ItemGroup>
+
+</Project>

src/Runtime/Ghost.Engine/IO/CustomSerializer.cs

@@ -0,0 +1,32 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Ghost.Engine.IO;
+
+public class CustomSerializerAttribute : JsonConverterAttribute
+{
+    public CustomSerializerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type serializerType)
+        : base(serializerType)
+    {
+    }
+}
+
+public abstract class CustomSerializer<T> : JsonConverter<T>
+{
+    public sealed override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return DeserializeJson(ref reader, options);
+    }
+
+    public sealed override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        SerializeJson(writer, value, options);
+    }
+
+    public abstract void SerializeJson(Utf8JsonWriter writer, T value, JsonSerializerOptions options);
+    public abstract T? DeserializeJson(ref Utf8JsonReader reader, JsonSerializerOptions options);
+
+    public abstract void SerializeBinary(BinaryWriter writer, T value);
+    public abstract T? DeserializeBinary(BinaryReader reader);
+}

src/Runtime/Ghost.Engine/Models/LaunchArgument.cs

@@ -0,0 +1,5 @@
+namespace Ghost.Engine.Models;
+
+internal class LaunchArgument
+{
+}

src/Runtime/Ghost.Engine/Resources/EngineData.cs

@@ -0,0 +1,8 @@
+namespace Ghost.Engine.Resources;
+
+internal class EngineData
+{
+    public const string ENGINE_NAME = "Ghost Engine";
+
+    public readonly static Version EngineVersion = new(0, 1, 0);
+}

src/Runtime/Ghost.Engine/Resources/EngineResource.cs

@@ -0,0 +1,13 @@
+using System.Text.Json;
+
+namespace Ghost.Engine.Resources;
+
+public static class EngineResource
+{
+    public static readonly JsonSerializerOptions defaultSerializerOptions = new()
+    {
+        WriteIndented = true,
+        IncludeFields = true,
+        IgnoreReadOnlyProperties = true,
+    };
+}

src/Runtime/Ghost.Engine/Utilities/MathUtility.cs

@@ -0,0 +1,54 @@
+using Misaki.HighPerformance.Mathematics;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Engine.Utilities;
+
+public static class MathUtility
+{
+    extension(float4x4 matrix)
+    {
+        /// <summary>
+        /// Creates a transformation matrix from position, rotation, and scale vectors.
+        /// </summary>
+        /// <param name="position">Defines the translation component of the transformation matrix.</param>
+        /// <param name="rotation">Specifies the orientation of the object in 3D space.</param>
+        /// <param name="scale">Determines the size of the object along each axis.</param>
+        /// <returns>Returns a transformation matrix that combines the specified position, rotation, and scale.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4x4 TRS(float3 position, quaternion rotation, float3 scale)
+        {
+            var R = new float3x3(rotation);
+            return new float4x4(
+                    R[0][0] * scale.x, R[0][1] * scale.y, R[0][2] * scale.z, position.x,
+                    R[1][0] * scale.x, R[1][1] * scale.y, R[1][2] * scale.z, position.y,
+                    R[2][0] * scale.x, R[2][1] * scale.y, R[2][2] * scale.z, position.z,
+                    0f, 0f, 0f, 1f
+                );
+        }
+
+        /// <summary>
+        /// Gets the translation, rotation, and scale components from a transformation matrix.
+        /// </summary>
+        /// <param name="position">The position component extracted from the matrix.</param>
+        /// <param name="rotation">The rotation component extracted from the matrix as a quaternion.</param>
+        /// <param name="scale">The scale component extracted from the matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTRS(out float3 position, out quaternion rotation, out float3 scale)
+        {
+            position = matrix.c3.xyz;
+
+            var scaleX = math.length(matrix.c0.xyz);
+            var scaleY = math.length(matrix.c1.xyz);
+            var scaleZ = math.length(matrix.c2.xyz);
+            scale = new float3(scaleX, scaleY, scaleZ);
+
+            var rotationMatrix = new float3x3(
+                matrix.c0.x / scale.x, matrix.c0.y / scale.x, matrix.c0.z / scale.x,
+                matrix.c1.x / scale.y, matrix.c1.y / scale.y, matrix.c1.z / scale.y,
+                matrix.c2.x / scale.z, matrix.c2.y / scale.z, matrix.c2.z / scale.z
+            );
+
+            rotation = new quaternion(rotationMatrix);
+        }
+    }
+}

src/Runtime/Ghost.Engine/Utilities/Utf8JsonWriterExtension.cs

@@ -0,0 +1,78 @@
+using System.Text.Json;
+
+namespace Ghost.Engine.Utilities;
+
+public readonly ref struct Utf8JsonObjectScope : IDisposable
+{
+    private readonly Utf8JsonWriter _writer;
+    public Utf8JsonObjectScope(Utf8JsonWriter writer)
+    {
+        _writer = writer;
+        _writer.WriteStartObject();
+    }
+    public void Dispose()
+    {
+        _writer.WriteEndObject();
+    }
+}
+
+public readonly ref struct Utf8JsonArrayScope : IDisposable
+{
+    private readonly Utf8JsonWriter _writer;
+    public Utf8JsonArrayScope(Utf8JsonWriter writer)
+    {
+        _writer = writer;
+        _writer.WriteStartArray();
+    }
+    public void Dispose()
+    {
+        _writer.WriteEndArray();
+    }
+}
+
+public static class Utf8JsonWriterExtension
+{
+    public static void WriteArray<T>(this Utf8JsonWriter writer, ReadOnlySpan<char> name, IEnumerable<T> source, Action<T> writeAction)
+    {
+        writer.WriteStartArray(name);
+        foreach (var item in source)
+        {
+            writeAction(item);
+        }
+        writer.WriteEndArray();
+    }
+
+    public static void WriteArray<T>(this Utf8JsonWriter writer, ReadOnlySpan<char> name, ReadOnlySpan<T> source, Action<T> writeAction)
+    {
+        writer.WriteStartArray(name);
+        foreach (var item in source)
+        {
+            writeAction(item);
+        }
+        writer.WriteEndArray();
+    }
+
+    public static void WriteObject(this Utf8JsonWriter writer, Action writeAction)
+    {
+        writer.WriteStartObject();
+        writeAction();
+        writer.WriteEndObject();
+    }
+
+    public static void WriteObject(this Utf8JsonWriter writer, ReadOnlySpan<char> name, Action writeAction)
+    {
+        writer.WriteStartObject(name);
+        writeAction();
+        writer.WriteEndObject();
+    }
+
+    public static Utf8JsonObjectScope StartObjectScope(this Utf8JsonWriter writer)
+    {
+        return new Utf8JsonObjectScope(writer);
+    }
+
+    public static Utf8JsonArrayScope StartArrayScope(this Utf8JsonWriter writer)
+    {
+        return new Utf8JsonArrayScope(writer);
+    }
+}

src/Runtime/Ghost.Entities/Archetype.cs

@@ -0,0 +1,712 @@
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+internal unsafe sealed class ChunkDebugView
+{
+    [DebuggerDisplay("{Name,nq}: {Data}")]
+    internal class ComponentArrayView
+    {
+        public string Name { get; }
+        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+        public object Data { get; }
+
+        public ComponentArrayView(string name, object data)
+        {
+            Name = name;
+            Data = data;
+        }
+    }
+
+    private Chunk _chunk;
+
+    public ChunkDebugView(Chunk chunk)
+    {
+        _chunk = chunk;
+    }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public object[] Items => GetItems(in _chunk);
+
+    private static T[] ReadComponentArray<T>(long pData, int offsetInChunk, int count)
+        where T : unmanaged
+    {
+        var result = new T[count];
+        unsafe
+        {
+            var basePtr = (byte*)pData + offsetInChunk;
+            var span = new Span<T>(basePtr, count);
+            span.CopyTo(result);
+        }
+
+        return result;
+    }
+
+    private static object[] GetItems(ref readonly Chunk chunk)
+    {
+#if !(DEBUG || GHOST_EDITOR)
+        return [];
+#else
+        var pData = chunk.GetUnsafePtr();
+        var count = chunk._count;
+        var capacity = chunk._capacity;
+        var worldID = chunk._worldID;
+        var archetypeID = chunk._archetypeID;
+
+        if (count == 0)
+        {
+            return [];
+        }
+
+        var views = new List<object>();
+        var world = World.GetWorld(worldID);
+        if (world is null)
+        {
+            return [];
+        }
+
+        ref var archetype = ref world.ComponentManager.GetArchetypeReference(archetypeID);
+        var it = archetype._signature.GetIterator();
+        while (it.Next(out var index))
+        {
+            var type = ComponentRegistry.s_runtimeIDToType[index];
+            if (type == null)
+            {
+                continue;
+            }
+            var layout = archetype.GetLayout(index).Value;
+            var readMethod = typeof(ChunkDebugView)
+                .GetMethod(nameof(ReadComponentArray), System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!
+                .MakeGenericMethod(type);
+
+            // 3. Invoke it to get a Position[] or Velocity[]
+            var array = readMethod.Invoke(null, [(long)pData, layout.offset, count]);
+            if (array == null)
+            {
+                continue;
+            }
+
+            // 4. Wrap it in a nice label so the debugger shows "Position[]"
+            views.Add(new ComponentArrayView(type.Name, array));
+        }
+
+        return [.. views];
+#endif
+    }
+}
+
+[DebuggerTypeProxy(typeof(ChunkDebugView))]
+internal unsafe struct Chunk : IDisposable
+{
+    public const int CHUNK_BUFFER_SIZE = 16384; // 16 KB
+    public const int BIT_ALIGNMENT = 8;
+    public const int BIT_SHIFT = 3; // log2(BIT_ALIGNMENT)
+    public const int BIT_ALIGNMENT_MINUS_ONE = BIT_ALIGNMENT - 1;
+
+    private UnsafeArray<byte> _data;
+    private UnsafeArray<int> _versions;
+
+    // TODO: Add structual change versioning, similar to DidOrderChange in unity ecs.
+    internal int _structuralVersion;
+
+    internal int _count;
+    internal readonly int _capacity;
+
+#if DEBUG || GHOST_EDITOR
+    // For debugging purpose
+    internal int _worldID;
+    internal int _archetypeID;
+#endif
+
+    public Chunk(int bufferSize, int capacity, int componentCount, int globalVersion)
+    {
+        _data = new UnsafeArray<byte>(bufferSize, Allocator.Persistent, AllocationOption.Clear);
+        _versions = new UnsafeArray<int>(componentCount, Allocator.Persistent);
+        _capacity = capacity;
+        _count = 0;
+
+        _versions.AsSpan().Fill(globalVersion);
+        _structuralVersion = globalVersion;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly byte* GetUnsafePtr()
+    {
+        return (byte*)_data.GetUnsafePtr();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int* GetVersionUnsafePtr()
+    {
+        return (int*)_versions.GetUnsafePtr();
+    }
+
+    public void Dispose()
+    {
+        _data.Dispose();
+        _versions.Dispose();
+    }
+}
+
+internal unsafe struct Archetype : IDisposable
+{
+    internal struct ComponentMemoryLayout
+    {
+        public int componentID;
+        public int size;
+        public int offset;
+        public int enableBitsOffset;
+        public int versionIndex;
+    }
+
+    private struct Edge
+    {
+        public int componentID;
+        public int targetArchetype; // can't use Identifier<Archetype> because cycle causer
+    }
+
+    internal UnsafeBitSet _signature;
+    internal UnsafeList<Chunk> _chunks;
+    internal UnsafeArray<ComponentMemoryLayout> _layouts;
+    internal UnsafeArray<int> _componentIDToLayoutIndex;
+
+    // TODO: Is hash map better?
+    private UnsafeList<Edge> _edgesAdd;
+    private UnsafeList<Edge> _edgesRemove;
+
+    private readonly Identifier<Archetype> _id;
+    private readonly Identifier<World> _worldID;
+
+    private readonly int _hash;
+    private int _entityCapacity;
+    private int _maxComponentID;
+    private int _entityIdsOffset;
+
+    public readonly Identifier<Archetype> ID => _id;
+    public readonly Identifier<World> WorldID => _worldID;
+
+    public readonly int EntityCapacity => _entityCapacity;
+    public readonly int ChunkCount => _chunks.Count;
+    public readonly int EntityIDsOffset => _entityIdsOffset;
+
+    public Archetype(Identifier<Archetype> id, Identifier<World> worldID, ReadOnlySpan<Identifier<IComponent>> componentIds)
+    {
+        _id = id;
+        _worldID = worldID;
+
+        _chunks = new UnsafeList<Chunk>(4, Allocator.Persistent);
+        _edgesAdd = new UnsafeList<Edge>(4, Allocator.Persistent);
+        _edgesRemove = new UnsafeList<Edge>(4, Allocator.Persistent);
+
+        if (componentIds.IsEmpty)
+        {
+            _signature = new UnsafeBitSet(1, Allocator.Persistent, AllocationOption.Clear);
+            _hash = 0;
+
+            _signature.ClearAll();
+            _entityCapacity = Chunk.CHUNK_BUFFER_SIZE / sizeof(Entity);
+
+            return;
+        }
+
+        var highestComponentID = 0;
+        for (var i = 0; i < componentIds.Length; i++)
+        {
+            if (componentIds[i] > highestComponentID)
+            {
+                highestComponentID = componentIds[i];
+            }
+        }
+
+        _signature = new UnsafeBitSet(highestComponentID + 1, Allocator.Persistent, AllocationOption.Clear);
+        _hash = _signature.GetHashCode();
+
+        CalculateLayout(componentIds);
+    }
+
+    private void CalculateLayout(ReadOnlySpan<Identifier<IComponent>> componentIds)
+    {
+        var entitySize = sizeof(Entity);
+        var entityAlign = (int)MemoryUtility.AlignOf<Entity>();
+
+        var components = (Span<ComponentInfo>)stackalloc ComponentInfo[componentIds.Length];
+        for (var i = 0; i < componentIds.Length; i++)
+        {
+            _signature.SetBit(componentIds[i]);
+            components[i] = ComponentRegistry.GetComponentInfo(componentIds[i]);
+        }
+
+        // Calculate total size per entity to get an initial capacity estimate
+        var bytesPerEntity = entitySize;
+        var maxComponentID = 0;
+        for (var i = 0; i < components.Length; i++)
+        {
+            var comp = components[i];
+            bytesPerEntity += comp.size;
+            if (comp.id > maxComponentID)
+            {
+                maxComponentID = comp.id;
+            }
+        }
+
+        _maxComponentID = maxComponentID;
+        _entityCapacity = Chunk.CHUNK_BUFFER_SIZE / bytesPerEntity;
+        _layouts = new UnsafeArray<ComponentMemoryLayout>(components.Length, Allocator.Persistent);
+        _componentIDToLayoutIndex = new UnsafeArray<int>(_maxComponentID + 1, Allocator.Persistent);
+
+        _componentIDToLayoutIndex.AsSpan().Fill(-1);
+
+        components.Sort((a, b) => b.alignment.CompareTo(a.alignment));
+        var tempOffsets = stackalloc int[components.Length];
+        var tempBitmaskOffsets = stackalloc int[components.Length];
+
+        while (_entityCapacity > 0)
+        {
+            var currentOffset = 0;
+            var fits = true;
+
+            currentOffset = (currentOffset + entityAlign - 1) & ~(entityAlign - 1);
+
+            _entityIdsOffset = currentOffset;
+            currentOffset += _entityCapacity * entitySize;
+
+            for (var i = 0; i < components.Length; i++)
+            {
+                var size = components[i].size;
+                var align = components[i].alignment;
+
+                currentOffset = (currentOffset + align - 1) & ~(align - 1);
+                tempOffsets[i] = currentOffset;
+                currentOffset += _entityCapacity * size;
+
+                var bitmaskOffset = -1;
+                if (components[i].isEnableable)
+                {
+                    var bitmaskSize = (_entityCapacity + Chunk.BIT_ALIGNMENT_MINUS_ONE) / Chunk.BIT_ALIGNMENT;
+                    // Reserve space for the bitmask (1 bit per entity)
+
+                    currentOffset = (currentOffset + Chunk.BIT_ALIGNMENT_MINUS_ONE) & ~Chunk.BIT_ALIGNMENT_MINUS_ONE; // Align
+                    bitmaskOffset = currentOffset;
+                    currentOffset += bitmaskSize;
+                }
+
+                tempBitmaskOffsets[i] = bitmaskOffset;
+
+                if (currentOffset > Chunk.CHUNK_BUFFER_SIZE)
+                {
+                    fits = false;
+                    break;
+                }
+            }
+
+            if (fits)
+            {
+                for (var i = 0; i < components.Length; i++)
+                {
+                    _layouts[i] = new ComponentMemoryLayout
+                    {
+                        componentID = components[i].id,
+                        offset = tempOffsets[i],
+                        size = components[i].size,
+                        enableBitsOffset = tempBitmaskOffsets[i],
+                        versionIndex = i
+                    };
+
+                    _componentIDToLayoutIndex[components[i].id] = i;
+                }
+
+                return;
+            }
+
+            _entityCapacity--;
+        }
+    }
+
+    public void AllocateEntity(out int chunkIndex, out int rowIndex)
+    {
+        var world = World.GetWorldUncheck(_worldID);
+
+        for (var i = 0; i < _chunks.Count; i++)
+        {
+            ref var chunk = ref _chunks[i];
+            if (chunk._count < _entityCapacity)
+            {
+                rowIndex = chunk._count;
+                chunk._count++;
+                chunk._structuralVersion = world.Version;
+                chunkIndex = i;
+
+                return;
+            }
+        }
+
+        // Need to allocate a new chunk
+        var newChunk = new Chunk(Chunk.CHUNK_BUFFER_SIZE, _entityCapacity, _layouts.Count, world.Version);
+#if DEBUG || GHOST_EDITOR
+        newChunk._worldID = _worldID;
+        newChunk._archetypeID = _id;
+#endif
+
+        // Set all enable to true by default for enableable components
+        for (var i = 0; i < _layouts.Count; i++)
+        {
+            var layout = _layouts[i];
+            if (layout.enableBitsOffset != -1)
+            {
+                var pChunk = newChunk.GetUnsafePtr();
+                var pBits = pChunk + layout.enableBitsOffset;
+                MemoryUtility.MemSet(pBits, 0xFF, (nuint)((_entityCapacity + Chunk.BIT_ALIGNMENT_MINUS_ONE) / Chunk.BIT_ALIGNMENT));
+            }
+        }
+
+        rowIndex = 0;
+        newChunk._count++;
+        chunkIndex = _chunks.Count;
+
+        _chunks.Add(newChunk);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Entity GetEntity(int chunkIndex, int rowIndex)
+    {
+        var chunk = _chunks[chunkIndex];
+        var chunkBase = chunk.GetUnsafePtr();
+        var src = chunkBase + _entityIdsOffset + (sizeof(Entity) * rowIndex);
+
+        return *(Entity*)src;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void SetEntity(int chunkIndex, int rowIndex, Entity entity)
+    {
+        var chunk = _chunks[chunkIndex];
+        var chunkBase = chunk.GetUnsafePtr();
+        var dst = chunkBase + _entityIdsOffset + (sizeof(Entity) * rowIndex);
+
+        MemoryUtility.MemCpy(dst, &entity, (nuint)sizeof(Entity));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Error SetComponentData(int chunkIndex, int rowIndex, Identifier<IComponent> componentID, void* pComponent)
+    {
+        var r = GetLayout(componentID);
+        if (r.Error != Error.None)
+        {
+            return r.Error;
+        }
+
+        var offset = r.Value.offset;
+        ref var chunk = ref _chunks[chunkIndex];
+
+        var chunkBase = chunk.GetUnsafePtr();
+        var size = ComponentRegistry.GetComponentInfo(componentID).size;
+        var dst = chunkBase + offset + (size * rowIndex);
+
+        MemoryUtility.MemCpy(dst, pComponent, (nuint)size);
+
+        var world = World.GetWorldUncheck(_worldID);
+        MarkChanged(chunkIndex, componentID, world.Version);
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly void* GetComponentData(int chunkIndex, int rowIndex, Identifier<IComponent> componentID)
+    {
+        var r = GetLayout(componentID);
+        if (r.Error != Error.None)
+        {
+            return null;
+        }
+
+        var offset = r.Value.offset;
+        var chunk = _chunks[chunkIndex];
+
+        var chunkBase = chunk.GetUnsafePtr();
+        var size = ComponentRegistry.GetComponentInfo(componentID).size;
+        return chunkBase + offset + (size * rowIndex);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ref Chunk GetChunkReference(int index)
+    {
+        return ref _chunks[index];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Result<ComponentMemoryLayout, Error> GetLayout(int componentID)
+    {
+        if (componentID >= _componentIDToLayoutIndex.Count)
+        {
+            return Error.InvalidArgument;
+        }
+
+        var layoutIndex = _componentIDToLayoutIndex[componentID];
+        if (layoutIndex == -1)
+        {
+            return Error.NotFound;
+        }
+
+        return _layouts[layoutIndex];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Error MarkChanged(int chunkIndex, int componentTypeId, int globalVersion)
+    {
+        var layoutResult = GetLayout(componentTypeId);
+        if (layoutResult.IsFailure)
+        {
+            return layoutResult.Error;
+        }
+
+        ref var chunk = ref _chunks[chunkIndex];
+        chunk.GetVersionUnsafePtr()[layoutResult.Value.versionIndex] = globalVersion;
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Result<int, Error> GetVersion(int chunkIndex, int componentTypeId)
+    {
+        var layoutResult = GetLayout(componentTypeId);
+        if (layoutResult.Error != Error.None)
+        {
+            return layoutResult.Error;
+        }
+
+        ref var chunk = ref _chunks[chunkIndex];
+        return chunk.GetVersionUnsafePtr()[layoutResult.Value.versionIndex];
+    }
+
+    public Error RemoveEntity(int chunkIndex, int rowIndex)
+    {
+        if (chunkIndex < 0 || chunkIndex >= _chunks.Count)
+        {
+            return Error.InvalidArgument;
+        }
+
+        var world = World.GetWorldUncheck(_worldID);
+        ref var chunk = ref _chunks[chunkIndex];
+        var lastIndex = chunk._count - 1;
+
+        // If we are NOT removing the very last entity, we must swap.
+        if (rowIndex != lastIndex)
+        {
+            var chunkBase = chunk.GetUnsafePtr();
+            var pLastEntity = chunkBase + _entityIdsOffset + (sizeof(Entity) * lastIndex);
+            var pRowEntity = chunkBase + _entityIdsOffset + (sizeof(Entity) * rowIndex);
+
+            var error = world.EntityManager.UpdateEntityLocation(*(Entity*)pLastEntity, _id, chunkIndex, rowIndex);
+            if (error != Error.None)
+            {
+                return error;
+            }
+
+            // Only operate the swap back after the update is succeed.
+            MemoryUtility.MemCpy(pRowEntity, pLastEntity, (nuint)sizeof(Entity));
+
+            for (var i = 0; i < _layouts.Count; i++)
+            {
+                var layout = _layouts[i];
+
+                var pRow = chunk.GetUnsafePtr() + layout.offset + (layout.size * rowIndex);
+                var pLast = chunk.GetUnsafePtr() + layout.offset + (layout.size * lastIndex);
+
+                MemoryUtility.MemCpy(pRow, pLast, (nuint)layout.size);
+            }
+        }
+
+        chunk._count--;
+        chunk._structuralVersion = world.Version;
+
+        return Error.None;
+    }
+
+    public Error RemoveEntities(int chunkIndex, ReadOnlySpan<int> sortedIndicesToRemove)
+    {
+        if (chunkIndex < 0 || chunkIndex >= _chunks.Count)
+        {
+            return Error.InvalidArgument;
+        }
+
+        if (sortedIndicesToRemove.Length == 0)
+        {
+            return Error.None;
+        }
+
+        ref var chunk = ref _chunks[chunkIndex];
+
+        int oldCount = chunk._count;
+        int removeCount = sortedIndicesToRemove.Length;
+        int newCount = oldCount - removeCount; // The boundary between "Keep" and "Drop"
+
+        var chunkBase = chunk.GetUnsafePtr();
+        var world = World.GetWorldUncheck(_worldID); // Typo fixed from 'wrold'
+
+        // Pointers for the swap logic
+        // 1. 'holePtr' tracks which index in the sorted list we are processing
+        int holePtr = 0;
+
+        // 2. 'candidateIndex' starts at the end of the OLD array and moves backward
+        int candidateIndex = oldCount - 1;
+
+        // 3. 'removalTailPtr' tracks removals at the end of the array to skip them
+        int removalTailPtr = sortedIndicesToRemove.Length - 1;
+
+        // Iterate through the holes that are strictly INSIDE the new valid range
+        while (holePtr < removeCount)
+        {
+            int holeIndex = sortedIndicesToRemove[holePtr];
+
+            // If the current hole is beyond the new count, it's in the "Drop Zone".
+            // Since the list is sorted, all subsequent holes are also in the drop zone.
+            // We are done filling holes.
+            if (holeIndex >= newCount)
+                break;
+
+            // --- Find a Valid Filler ---
+            // We look for an entity at the end of the array that IS NOT scheduled for removal.
+            while (candidateIndex >= newCount)
+            {
+                // Check if the current candidate is actually marked for removal
+                bool isCandidateRemoved = false;
+
+                // Because sortedIndices is sorted, we check the end of the list 
+                // to see if the candidateIndex matches a removal request.
+                if (removalTailPtr >= 0 && sortedIndicesToRemove[removalTailPtr] == candidateIndex)
+                {
+                    isCandidateRemoved = true;
+                    removalTailPtr--; // Consume this removal
+                }
+
+                if (!isCandidateRemoved)
+                {
+                    // Found a valid filler!
+                    break;
+                }
+
+                // This candidate was also removed, so skip it and keep looking left
+                candidateIndex--;
+            }
+
+            // --- Perform The Swap ---
+            // Move 'candidateIndex' (Filler) into 'holeIndex' (Hole)
+
+            var pFillerEntity = chunkBase + _entityIdsOffset + (sizeof(Entity) * candidateIndex);
+            var pHoleEntity = chunkBase + _entityIdsOffset + (sizeof(Entity) * holeIndex);
+
+            // 1. Update the Map (Critical Step)
+            // We tell the world: "The entity that WAS at 'candidateIndex' is now at 'holeIndex'"
+            var result = world.EntityManager.UpdateEntityLocation(*(Entity*)pFillerEntity, _id, chunkIndex, holeIndex);
+            if (result != Error.None)
+            {
+                return result;
+            }
+
+            // 2. Overwrite Entity ID
+            MemoryUtility.MemCpy(pHoleEntity, pFillerEntity, (nuint)sizeof(Entity));
+
+            // 3. Overwrite Components
+            for (var i = 0; i < _layouts.Count; i++)
+            {
+                var layout = _layouts[i];
+                var pRow = chunkBase + layout.offset + (layout.size * holeIndex);
+                var pLast = chunkBase + layout.offset + (layout.size * candidateIndex);
+                MemoryUtility.MemCpy(pRow, pLast, (nuint)layout.size);
+            }
+
+            // Prepare for next hole
+            holePtr++;
+            candidateIndex--;
+        }
+
+        chunk._count = newCount;
+        chunk._structuralVersion = world.Version;
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool HasComponent(Identifier<IComponent> componentID)
+    {
+        return _signature.IsSet(componentID);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddEdgeAdd(Identifier<IComponent> componentID, Identifier<Archetype> targetArchetype)
+    {
+        _edgesAdd.Add(new Edge
+        {
+            componentID = componentID,
+            targetArchetype = targetArchetype
+        });
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Identifier<Archetype> GetEdgeAdd(Identifier<IComponent> componentID)
+    {
+        for (var i = 0; i < _edgesAdd.Count; i++)
+        {
+            var edge = _edgesAdd[i];
+            if (edge.componentID == componentID)
+            {
+                return edge.targetArchetype;
+            }
+        }
+
+        return Identifier<Archetype>.Invalid;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddEdgeRemove(Identifier<IComponent> componentID, Identifier<Archetype> targetArchetype)
+    {
+        _edgesRemove.Add(new Edge
+        {
+            componentID = componentID,
+            targetArchetype = targetArchetype
+        });
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Identifier<Archetype> GetEdgeRemove(Identifier<IComponent> componentID)
+    {
+        for (var i = 0; i < _edgesRemove.Count; i++)
+        {
+            var edge = _edgesRemove[i];
+            if (edge.componentID == componentID)
+            {
+                return edge.targetArchetype;
+            }
+        }
+
+        return Identifier<Archetype>.Invalid;
+    }
+
+    public override readonly int GetHashCode()
+    {
+        return _hash;
+    }
+
+    public void Dispose()
+    {
+        if (_chunks.IsCreated)
+        {
+            foreach (ref var chunk in _chunks)
+            {
+                chunk.Dispose();
+            }
+        }
+
+        _signature.Dispose();
+        _chunks.Dispose();
+        _componentIDToLayoutIndex.Dispose();
+        _layouts.Dispose();
+        _edgesAdd.Dispose();
+        _edgesRemove.Dispose();
+    }
+}

src/Runtime/Ghost.Entities/AssemblyInfo.cs

@@ -0,0 +1,12 @@
+global using EntityID = System.Int32;
+global using GenerationID = System.Int32;
+
+using Ghost.Core.Attributes;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Ghost.Engine")]
+[assembly: InternalsVisibleTo("Ghost.Editor.Core")]
+[assembly: InternalsVisibleTo("Ghost.Entities.Test")]
+
+[assembly: EngineAssembly]
+

src/Runtime/Ghost.Entities/Common.cs

@@ -0,0 +1,19 @@
+namespace Ghost.Entities;
+
+public readonly struct TimeData
+{
+    public int FrameCount
+    {
+        get; init;
+    }
+
+    public float DeltaTime
+    {
+        get; init;
+    }
+
+    public double ElapsedTime
+    {
+        get; init;
+    }
+}

src/Runtime/Ghost.Entities/Component.cs

@@ -0,0 +1,330 @@
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public interface IComponent
+{
+}
+
+public interface IEnableableComponent : IComponent
+{
+}
+
+internal struct ComponentInfo
+{
+    // public string stableName; // Do we actually need this?
+    public Identifier<IComponent> id;
+    public int size;
+    public int alignment;
+    public bool isEnableable;
+    public bool isShared;
+}
+
+/// <summary>
+/// Provides a unique identifier for the specified unmanaged component space.
+/// </summary>
+/// <typeparam name="T">The component space for which to obtain an identifier. Must be unmanaged and implement <see cref="IComponent"/>.</typeparam>
+public static class ComponentTypeID<T>
+    where T : unmanaged, IComponent
+{
+    public static readonly Identifier<IComponent> Value = ComponentRegistry.GetOrRegisterComponentID<T>();
+}
+
+internal static class ComponentRegistry
+{
+    private static readonly List<ComponentInfo> s_registeredComponents = new();
+    private static readonly Dictionary<IntPtr, int> s_typeHandleToID = new();
+    private static readonly Dictionary<string, int> s_nameToRuntimeID = new();
+
+    internal static readonly Dictionary<int, Type> s_runtimeIDToType = new();
+
+    public static unsafe Identifier<IComponent> GetOrRegisterComponentID<T>()
+        where T : unmanaged, IComponent
+    {
+        var type = typeof(T);
+        var typeHandle = type.TypeHandle.Value;
+
+        lock (s_registeredComponents)
+        {
+            if (s_typeHandleToID.TryGetValue(typeHandle, out var existingID))
+            {
+                return existingID;
+            }
+
+            var newID = new Identifier<IComponent>(s_registeredComponents.Count);
+            var stableName = typeof(T).FullName ?? typeof(T).Name;
+            var info = new ComponentInfo
+            {
+                // stableName = new FixedText64(stableName),
+                id = newID,
+                size = sizeof(T),
+                alignment = (int)MemoryUtility.AlignOf<T>(),
+                isEnableable = typeof(IEnableableComponent).IsAssignableFrom(type),
+                //isShared = typeof(ISharedComponent).IsAssignableFrom(type),
+            };
+
+            s_registeredComponents.Add(info);
+
+            s_typeHandleToID[typeHandle] = newID;
+            s_nameToRuntimeID[stableName] = newID;
+            s_runtimeIDToType[newID.Value] = typeof(T);
+
+            return newID;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Identifier<IComponent> GetComponentID(Type type)
+    {
+        var typeHandle = type.TypeHandle.Value;
+        lock (s_registeredComponents)
+        {
+            if (s_typeHandleToID.TryGetValue(typeHandle, out var existingID))
+            {
+                return existingID;
+            }
+        }
+
+        return Identifier<IComponent>.Invalid;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ComponentInfo GetComponentInfo(Identifier<IComponent> typeId)
+    {
+        lock (s_registeredComponents)
+        {
+            return s_registeredComponents[typeId];
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ComponentInfo GetComponentInfo(Type type)
+    {
+        lock (s_registeredComponents)
+        {
+            var typeId = GetComponentID(type);
+            if (typeId.IsInvalid)
+            {
+                throw new KeyNotFoundException($"Component type {type.FullName} is not registered.");
+            }
+
+            return s_registeredComponents[typeId];
+        }
+    }
+
+    public static int GetHashCode(params ReadOnlySpan<Identifier<IComponent>> componentTypeIDs)
+    {
+        var largestID = 0;
+        foreach (var id in componentTypeIDs)
+        {
+            if (id.Value > largestID)
+            {
+                largestID = id.Value;
+            }
+        }
+
+        var length = UnsafeBitSet.RequiredLength(largestID + 1);
+        var bits = (Span<uint>)stackalloc uint[length];
+        bits.Clear();
+
+        var bitSet = new SpanBitSet(bits);
+        foreach (var id in componentTypeIDs)
+        {
+            bitSet.SetBit(id.Value);
+        }
+
+        return bitSet.GetHashCode();
+    }
+}
+
+public class ComponentManager : IDisposable
+{
+    private readonly World _world;
+
+    private UnsafeList<Archetype> _archetypes;
+    private UnsafeList<EntityQuery> _entityQueries;
+
+    private UnsafeHashMap<int, Identifier<Archetype>> _archetypeLookup; // Signature Hash to Archetype ID
+    private UnsafeHashMap<int, Identifier<EntityQuery>> _querieLookup; // Query Mask Hash to Query ID
+
+    private bool _isDisposed;
+
+    public int ArchetypeCount => _archetypes.Count;
+
+    internal ComponentManager(World world)
+    {
+        _world = world;
+
+        _archetypes = new UnsafeList<Archetype>(16, Allocator.Persistent);
+        _entityQueries = new UnsafeList<EntityQuery>(16, Allocator.Persistent);
+
+        _archetypeLookup = new UnsafeHashMap<int, Identifier<Archetype>>(16, Allocator.Persistent);
+        _querieLookup = new UnsafeHashMap<int, Identifier<EntityQuery>>(16, Allocator.Persistent);
+
+        // Create the empty archetype
+        CreateArchetype(ReadOnlySpan<Identifier<IComponent>>.Empty, 0);
+    }
+
+    ~ComponentManager()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Identifier<Archetype> CreateArchetype(ReadOnlySpan<Identifier<IComponent>> componentTypeIDs, int signatureHash)
+    {
+        var arcID = new Identifier<Archetype>(_archetypes.Count);
+        _archetypes.Add(new Archetype(arcID, _world.ID, componentTypeIDs));
+        _archetypeLookup.Add(signatureHash, arcID);
+
+        for (int i = 0; i < _entityQueries.Count; i++)
+        {
+            ref var query = ref _entityQueries[i];
+            query.AddArchetypeIfMatch(in _archetypes[arcID.Value]);
+        }
+
+        return arcID;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Identifier<Archetype> GetArchetypeIDBySignatureHash(int signatureHash)
+    {
+        if (_archetypeLookup.TryGetValue(signatureHash, out var arcID))
+        {
+            return arcID;
+        }
+
+        return Identifier<Archetype>.Invalid;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal ref Archetype GetArchetypeReference(Identifier<Archetype> id)
+    {
+        return ref _archetypes[id.Value];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Identifier<EntityQuery> CreateEntityQuery(EntityQueryMask mask, int maskHash)
+    {
+        var queryID = new Identifier<EntityQuery>(_entityQueries.Count);
+        _entityQueries.Add(new EntityQuery(queryID, _world.ID, mask));
+        _querieLookup.Add(maskHash, queryID);
+
+        ref var query = ref _entityQueries[queryID.Value];
+        for (var i = 0; i < _archetypes.Count; i++)
+        {
+            query.AddArchetypeIfMatch(in _archetypes[i]);
+        }
+
+        return queryID;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal Identifier<EntityQuery> GetEntityQueryIDByMaskHash(int maskHash)
+    {
+        if (_querieLookup.TryGetValue(maskHash, out var queryID))
+        {
+            return queryID;
+        }
+
+        return Identifier<EntityQuery>.Invalid;
+    }
+
+    /// <summary>
+    /// Gets a reference to the entity query with the specified identifier.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ref EntityQuery GetEntityQueryReference(Identifier<EntityQuery> id)
+    {
+        return ref _entityQueries[id.Value];
+    }
+
+    public void Dispose()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        foreach (ref var archetype in _archetypes)
+        {
+            archetype.Dispose();
+        }
+
+        foreach (ref var query in _entityQueries)
+        {
+            query.Dispose();
+        }
+
+        _archetypes.Dispose();
+        _entityQueries.Dispose();
+        _archetypeLookup.Dispose();
+        _querieLookup.Dispose();
+
+        _isDisposed = true;
+        GC.SuppressFinalize(this);
+    }
+}
+
+/// <summary>
+/// Represents an immutable set of component identifiers used to define a group of components within an entity or system.
+/// </summary>
+public struct ComponentSet : IDisposable, IEquatable<ComponentSet>
+{
+    private UnsafeArray<Identifier<IComponent>> _components;
+    private int _hashCode;
+
+    public readonly ReadOnlySpan<Identifier<IComponent>> Components => _components.AsSpan();
+
+    public ComponentSet(AllocationHandle allocationHandle, params ReadOnlySpan<Identifier<IComponent>> components)
+    {
+        _components = new UnsafeArray<Identifier<IComponent>>(components.Length, allocationHandle);
+        components.CopyTo(_components.AsSpan());
+
+        _hashCode = -1;
+    }
+
+    public ComponentSet(Allocator allocator, params ReadOnlySpan<Identifier<IComponent>> components)
+        : this(AllocationManager.GetAllocationHandle(allocator), components)
+    {
+    }
+
+    public readonly bool Equals(ComponentSet other)
+    {
+        return _hashCode == other._hashCode;
+    }
+
+    public override int GetHashCode()
+    {
+        if (_hashCode == -1)
+        {
+            _hashCode = ComponentRegistry.GetHashCode(_components.AsSpan());
+        }
+
+        return _hashCode;
+    }
+
+    public override readonly bool Equals(object? obj)
+    {
+        return obj is ComponentSet set && Equals(set);
+    }
+
+    public static bool operator ==(ComponentSet left, ComponentSet right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(ComponentSet left, ComponentSet right)
+    {
+        return !(left == right);
+    }
+
+    public void Dispose()
+    {
+        _components.Dispose();
+    }
+}

src/Runtime/Ghost.Entities/Entity.cs

@@ -0,0 +1,48 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Entities;
+
+[StructLayout(LayoutKind.Sequential, Size = 8)]
+public readonly record struct Entity
+{
+    public const EntityID INVALID_ID = -1;
+
+    private readonly EntityID _id;
+    private readonly GenerationID _generation;
+
+    public EntityID ID
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _id;
+    }
+
+    public GenerationID Generation
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => _generation;
+    }
+
+    public bool IsValid
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ID != INVALID_ID;
+    }
+
+    public static Entity Invalid
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new(INVALID_ID, INVALID_ID);
+    }
+
+    internal Entity(EntityID id, GenerationID generation)
+    {
+        _id = id;
+        _generation = generation;
+    }
+
+    public override string ToString()
+    {
+        return $"Entity {{ Index: {ID}, Generation: {Generation} }}";
+    }
+}

src/Runtime/Ghost.Entities/EntityCommandBuffer.cs

@@ -0,0 +1,225 @@
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public unsafe class EntityCommandBuffer : IDisposable
+{
+    private enum ECBOpCode : byte
+    {
+        CreateEntity,
+        CreateEntityWithComponents,
+        DestroyEntity,
+        AddComponent,
+        RemoveComponent,
+        SetComponent,
+    }
+
+    private readonly EntityManager _entityManager;
+    private UnsafeList<byte> _buffer;
+    private bool _disposed;
+
+    public EntityCommandBuffer(EntityManager entityManager)
+    {
+        _entityManager = entityManager;
+        _buffer = new UnsafeList<byte>(4096, Allocator.Persistent);
+    }
+
+    ~EntityCommandBuffer()
+    {
+        Dispose();
+    }
+
+    private void WriteHeader(ECBOpCode op)
+    {
+        _buffer.Add((byte)op);
+    }
+
+    private void Write<T>(T value)
+        where T : unmanaged
+    {
+        var size = sizeof(T);
+        var idx = _buffer.Count;
+
+        if (idx + size > _buffer.Capacity)
+        {
+            _buffer.Resize(idx + size);
+        }
+
+        MemoryUtility.MemCpy((byte*)_buffer.GetUnsafePtr() + idx, &value, (nuint)size);
+    }
+
+    private void WriteSpan<T>(ReadOnlySpan<T> span)
+        where T : unmanaged
+    {
+        var size = sizeof(T) * span.Length;
+        var idx = _buffer.Count;
+
+        if (idx + size > _buffer.Capacity)
+        {
+            _buffer.Resize(idx + size);
+        }
+
+        fixed (T* ptr = span)
+        {
+            MemoryUtility.MemCpy((byte*)_buffer.GetUnsafePtr() + idx, ptr, (nuint)size);
+        }
+    }
+
+    private T Read<T>(ref int cursor)
+        where T : unmanaged
+    {
+        var size = sizeof(T);
+        var ptr = (byte*)_buffer.GetUnsafePtr();
+
+        var value = *(T*)&ptr[cursor];
+        cursor += size;
+
+        return value;
+    }
+
+    private Span<T> ReadSpan<T>(ref int cursor, int length)
+        where T : unmanaged
+    {
+        var size = sizeof(T) * length;
+        var ptr = (byte*)_buffer.GetUnsafePtr();
+
+        var span = new Span<T>(&ptr[cursor], length);
+        cursor += size;
+
+        return span;
+    }
+
+    private void* ReadBuffer(ref int cursor, int size)
+    {
+        var ptr = (byte*)_buffer.GetUnsafePtr();
+        var bufferPtr = ptr + cursor;
+        cursor += size;
+
+        return bufferPtr;
+    }
+
+    public void CreateEntity(int count = 1)
+    {
+        WriteHeader(ECBOpCode.CreateEntity);
+        Write(count);
+    }
+
+    public void CreateEntity(int count, ComponentSet set)
+    {
+        WriteHeader(ECBOpCode.CreateEntityWithComponents);
+        Write(count);
+        Write(set.Components.Length);
+        WriteSpan(set.Components);
+    }
+
+    public void DestroyEntity(Entity entity)
+    {
+        WriteHeader(ECBOpCode.DestroyEntity);
+        Write(entity);
+    }
+
+    public void AddComponent<T>(Entity entity, T component = default)
+        where T : unmanaged, IComponent
+    {
+        WriteHeader(ECBOpCode.AddComponent);
+        Write(entity);
+        Write(ComponentTypeID<T>.Value);
+        Write(component);
+    }
+
+    public void RemoveComponent<T>(Entity entity)
+        where T : unmanaged, IComponent
+    {
+        WriteHeader(ECBOpCode.RemoveComponent);
+        Write(entity);
+        Write(ComponentTypeID<T>.Value);
+    }
+
+    public void SetComponent<T>(Entity entity, T component)
+        where T : unmanaged, IComponent
+    {
+        WriteHeader(ECBOpCode.SetComponent);
+        Write(entity);
+        Write(ComponentTypeID<T>.Value);
+        Write(component);
+    }
+
+    internal void Playback()
+    {
+        var cursor = 0;
+        var length = _buffer.Count;
+
+        while (cursor < length)
+        {
+            var op = Read<ECBOpCode>(ref cursor);
+
+            using var scope = AllocationManager.CreateStackScope();
+
+            switch (op)
+            {
+                case ECBOpCode.CreateEntity:
+                    var count = Read<int>(ref cursor);
+                    _entityManager.CreateEntities(count);
+                    break;
+
+                case ECBOpCode.CreateEntityWithComponents:
+                    var entityCount = Read<int>(ref cursor);
+                    var compCount = Read<int>(ref cursor);
+                    var compTypeIDs = ReadSpan<Identifier<IComponent>>(ref cursor, compCount);
+                    var set = new ComponentSet(scope.AllocationHandle, compTypeIDs);
+                    _entityManager.CreateEntities(entityCount, set);
+                    break;
+
+                case ECBOpCode.DestroyEntity:
+                    var entityToDestroy = Read<Entity>(ref cursor);
+                    _entityManager.DestroyEntity(entityToDestroy);
+                    break;
+
+                case ECBOpCode.AddComponent:
+                    var entityToAdd = Read<Entity>(ref cursor);
+                    var addCompTypeID = Read<Identifier<IComponent>>(ref cursor);
+                    var pAddCompData = ReadBuffer(ref cursor, ComponentRegistry.GetComponentInfo(addCompTypeID).size);
+                    _entityManager.AddComponent(entityToAdd, addCompTypeID, pAddCompData);
+                    break;
+
+                case ECBOpCode.RemoveComponent:
+                    var entityToRemove = Read<Entity>(ref cursor);
+                    var removeCompTypeID = Read<Identifier<IComponent>>(ref cursor);
+                    _entityManager.RemoveComponent(entityToRemove, removeCompTypeID);
+                    break;
+
+                case ECBOpCode.SetComponent:
+                    var entityToSet = Read<Entity>(ref cursor);
+                    var setCompTypeID = Read<Identifier<IComponent>>(ref cursor);
+                    var pSetCompData = ReadBuffer(ref cursor, ComponentRegistry.GetComponentInfo(setCompTypeID).size);
+                    _entityManager.SetComponent(entityToSet, setCompTypeID, pSetCompData);
+                    break;
+            }
+        }
+
+        Reset();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void Reset()
+    {
+        _buffer.Clear();
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _buffer.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Entities/EntityManager.Managed.cs

@@ -0,0 +1,224 @@
+using Misaki.HighPerformance.Collections;
+using Misaki.HighPerformance.Utilities;
+
+namespace Ghost.Entities;
+
+public partial class EntityManager
+{
+    private readonly SlotMap<List<ScriptComponent>> _scriptComponents;
+
+    internal SlotMap<List<ScriptComponent>> ScriptComponents => _scriptComponents;
+
+    /// <summary>
+    /// Creates a new ManagedEntity and associates it with the given Entity.
+    /// </summary>
+    /// <param name="entity">The Entity to associate with the ManagedEntity.</param>
+    /// <returns>The created ManagedEntity.</returns>
+    public ManagedEntity CreateManagedEntity(Entity entity)
+    {
+        var managedEntity = CreateManagedEntity();
+        AddComponent(entity, new ManagedEntityRef
+        {
+            entity = managedEntity
+        });
+
+        return managedEntity;
+    }
+
+    /// <summary>
+    /// Creates a new ManagedEntity.
+    /// </summary>
+    /// <remarks>
+    /// You must call this if you add <see cref="ManagedEntityRef"/> manually to an entity.
+    /// Otherwise, use <see cref="CreateManagedEntity(Entity)"/>.
+    /// </remarks>
+    /// <returns>The created ManagedEntity.</returns>
+    public ManagedEntity CreateManagedEntity()
+    {
+        var id = _scriptComponents.Add(new(8), out var generation);
+        var managedEntity = new ManagedEntity
+        {
+            id = id,
+            generation = generation
+        };
+
+        return managedEntity;
+    }
+
+    /// <summary>
+    /// Destroys the given ManagedEntity and calls OnDestroy on all associated ScriptComponents.
+    /// </summary>
+    /// <param name="managedEntity">The ManagedEntity to destroy.</param>
+    public void DestroyManagedEntity(ManagedEntity managedEntity)
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            foreach (var script in scripts)
+            {
+                script.OnDestroy();
+            }
+
+            _scriptComponents.Remove(managedEntity.id, managedEntity.generation);
+        }
+    }
+
+    /// <summary>
+    /// Checks if the given ManagedEntity exists.
+    /// </summary>
+    /// <param name="managedEntity">The ManagedEntity to check.</param>
+    /// <returns>True if the ManagedEntity exists, false otherwise.</returns>
+    public bool Exists(ManagedEntity managedEntity)
+    {
+        return _scriptComponents.Contains(managedEntity.id, managedEntity.generation);
+    }
+
+    /// <summary>
+    /// Adds a ScriptComponent of space T to the given ManagedEntity and Entity.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to add.</typeparam>
+    /// <param name="managedEntity">The ManagedEntity to add the ScriptComponent to.</
+    /// <param name="entity">The Entity associated with the ManagedEntity.</param>
+    public void AddScriptComponent<T>(ManagedEntity managedEntity, Entity entity)
+        where T : ScriptComponent, new()
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            var script = new T
+            {
+                _world = _world,
+                _entity = entity,
+                _managedEntity = managedEntity
+            };
+
+            scripts.Add(script);
+            script.OnCreate();
+
+            return;
+        }
+
+        throw new InvalidOperationException($"ManagedEntity {managedEntity} does not exist.");
+    }
+
+    /// <summary>
+    /// Adds a ScriptComponent of space T to the given Entity.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to add.</typeparam>
+    /// <param name="entity">The Entity to add the ScriptComponent to.</param>
+    public unsafe void AddScriptComponent<T>(Entity entity)
+        where T : ScriptComponent, new()
+    {
+        var location = _entityLocations.GetElementAt(entity.ID, entity.Generation);
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+
+        var pManagedEntityRef = (ManagedEntityRef*)archetype.GetComponentData(location.chunkIndex, location.rowIndex, ComponentTypeID<ManagedEntityRef>.Value);
+        if (pManagedEntityRef == null)
+        {
+            throw new InvalidOperationException($"Entity {entity} does not have ManagedEntityRef component.");
+        }
+
+        AddScriptComponent<T>(pManagedEntityRef->entity, entity);
+    }
+
+    /// <summary>
+    /// Destroys the ScriptComponent of space T associated with the given ManagedEntity.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to destroy.</typeparam>
+    /// <param name="managedEntity">The ManagedEntity whose ScriptComponent is to be destroyed </param>
+    /// <returns>True if the ScriptComponent was found and destroyed, false otherwise.</returns
+    public bool DestroyScriptComponent<T>(ManagedEntity managedEntity)
+        where T : ScriptComponent
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            for (var i = 0; i < scripts.Count; i++)
+            {
+                if (scripts[i] is T script)
+                {
+                    script.OnDestroy();
+                    scripts.RemoveAndSwapBack(i);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        throw new InvalidOperationException($"ManagedEntity {managedEntity} does not exist.");
+    }
+
+    /// <summary>
+    /// Checks if the given ManagedEntity has a ScriptComponent of space T.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to check for.</typeparam>
+    /// <param name="managedEntity">The ManagedEntity to check.</param>
+    /// <returns>True if the ManagedEntity has a ScriptComponent of space T, false </returns>
+    public bool HasScriptComponent<T>(ManagedEntity managedEntity)
+        where T : ScriptComponent
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            foreach (var script in scripts)
+            {
+                if (script is T)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        throw new InvalidOperationException($"ManagedEntity {managedEntity} does not exist.");
+    }
+
+    /// <summary>
+    /// Gets the ScriptComponent of space T associated with the given ManagedEntity.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to get.</typeparam>
+    /// <param name="managedEntity">The ManagedEntity whose ScriptComponent is to be retrieved
+    /// <returns>The ScriptComponent of space T.</returns>
+    public T GetScriptComponent<T>(ManagedEntity managedEntity)
+        where T : ScriptComponent
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            foreach (var script in scripts)
+            {
+                if (script is T typedScript)
+                {
+                    return typedScript;
+                }
+            }
+
+            throw new InvalidOperationException($"ManagedEntity {managedEntity} does not have script component of type {typeof(T)}.");
+        }
+
+        throw new InvalidOperationException($"ManagedEntity {managedEntity} does not exist.");
+    }
+
+    /// <summary>
+    /// Gets all ScriptComponents of space T associated with the given ManagedEntity.
+    /// </summary>
+    /// <typeparam name="T">The space of ScriptComponent to get.</typeparam>
+    /// <param name="managedEntity">The ManagedEntity whose ScriptComponents are to be retrieved
+    /// <returns>The list of ScriptComponents of space T.</returns>
+    public List<T> GetScriptComponents<T>(ManagedEntity managedEntity)
+        where T : ScriptComponent
+    {
+        if (_scriptComponents.TryGetElement(managedEntity.id, managedEntity.generation, out var scripts))
+        {
+            var result = new List<T>();
+            foreach (var script in scripts)
+            {
+                if (script is T typedScript)
+                {
+                    result.Add(typedScript);
+                }
+            }
+
+            return result;
+        }
+
+        throw new InvalidOperationException($"ManagedEntity {managedEntity} does not exist.");
+    }
+}

src/Runtime/Ghost.Entities/EntityManager.cs

@@ -0,0 +1,864 @@
+using Ghost.Core;
+using Misaki.HighPerformance.Collections;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Diagnostics;
+
+namespace Ghost.Entities;
+
+internal struct EntityLocation : IComparable<EntityLocation>
+{
+    public int archetypeID;
+    public int chunkIndex;
+    public int rowIndex;
+
+    public readonly int CompareTo(EntityLocation other)
+    {
+        var archComp = chunkIndex.CompareTo(other.chunkIndex);
+        if (archComp != 0)
+        {
+            return archComp;
+        }
+
+        var chunkComp = chunkIndex.CompareTo(other.chunkIndex);
+        if (chunkComp != 0)
+        {
+            return chunkComp;
+        }
+
+        return rowIndex.CompareTo(other.rowIndex);
+    }
+}
+
+/// <summary>
+/// A manager for creating, destroying, and managing entities and their components.
+/// </summary>
+/// <remarks>
+/// All methods in this class are not thread-safe and all of them will cause structural changes if not mentioned otherwise.
+/// Use <see cref="EntityCommandBuffer"/> to defer structural changes to a safe point.
+/// Use <see cref="World.GetThreadLocalEntityCommandBuffer(int)"/> to get a thread-local command buffer for multithreaded scenarios.
+/// </remarks>
+public unsafe partial class EntityManager : IDisposable
+{
+    private readonly World _world;
+    private UnsafeSlotMap<EntityLocation> _entityLocations;
+    private bool _disposed;
+
+    public World World => _world;
+
+    internal EntityManager(World world, int initialCapacity)
+    {
+        _world = world;
+        _entityLocations = new UnsafeSlotMap<EntityLocation>(initialCapacity, Allocator.Persistent, AllocationOption.Clear);
+        _scriptComponents = new SlotMap<List<ScriptComponent>>(initialCapacity / 2);
+        // _storages = new IManagedComponentStorage[16];
+    }
+
+    ~EntityManager()
+    {
+        Dispose();
+    }
+
+    internal Error UpdateEntityLocation(Entity entity, Identifier<Archetype> newArchetypeID, int newChunkIndex, int newRowIndex)
+    {
+        ref var location = ref _entityLocations.GetElementReferenceAt(entity.ID, entity.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        location.archetypeID = newArchetypeID;
+        location.chunkIndex = newChunkIndex;
+        location.rowIndex = newRowIndex;
+
+        return Error.None;
+    }
+
+    internal Result<EntityLocation, Error> GetEntityLocation(Entity entity)
+    {
+        if (_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return location;
+        }
+
+        return Error.NotFound;
+    }
+
+    /// <summary>
+    /// Create an entity with no components.
+    /// </summary>
+    /// <returns>The created entity.</returns>
+    public Entity CreateEntity()
+    {
+        var entities = (Span<Entity>)stackalloc Entity[1];
+        CreateEntities(entities);
+
+        return entities[0];
+    }
+
+    /// <summary>
+    /// Create an entity with specified components.
+    /// </summary>
+    /// <param name="set">A set of component space IDs to add to the entities.</param>
+    /// <returns>The created entity.</returns>
+    public Entity CreateEntity(ComponentSet set)
+    {
+        var entities = (Span<Entity>)stackalloc Entity[1];
+        CreateEntities(entities, set);
+
+        return entities[0];
+    }
+
+    /// <summary>
+    /// Create multiple entities with no components.
+    /// </summary>
+    /// <param name="entities">The span to store the created entities.</param>
+    public void CreateEntities(Span<Entity> entities)
+    {
+        ref var emptyArchetype = ref _world.ComponentManager.GetArchetypeReference(World.EmptyArchetypeID);
+        emptyArchetype.AllocateEntity(out var chunkIndex, out var rowIndex);
+
+        for (var i = 0; i < entities.Length; i++)
+        {
+            var id = _entityLocations.Add(new EntityLocation
+            {
+                archetypeID = World.EmptyArchetypeID,
+                chunkIndex = chunkIndex,
+                rowIndex = rowIndex
+            }, out var generation);
+
+            var entity = new Entity(id, generation);
+            emptyArchetype.SetEntity(chunkIndex, rowIndex, entity);
+
+            entities[i] = entity;
+        }
+    }
+
+    /// <summary>
+    /// Create multiple entities with no components.
+    /// </summary>
+    /// <param name="count">The number of entities to create.</param>
+    public void CreateEntities(int count)
+    {
+        ref var emptyArchetype = ref _world.ComponentManager.GetArchetypeReference(World.EmptyArchetypeID);
+        emptyArchetype.AllocateEntity(out var chunkIndex, out var rowIndex);
+
+        for (var i = 0; i < count; i++)
+        {
+            var id = _entityLocations.Add(new EntityLocation
+            {
+                archetypeID = World.EmptyArchetypeID,
+                chunkIndex = chunkIndex,
+                rowIndex = rowIndex
+            }, out var generation);
+
+            var entity = new Entity(id, generation);
+            emptyArchetype.SetEntity(chunkIndex, rowIndex, entity);
+        }
+    }
+
+    /// <summary>
+    /// Create multiple entities with specified components.
+    /// </summary>
+    /// <param name="entities">The span to store the created entities.</param>
+    /// <param name="set">A set of component space IDs to add to the entities.</param>
+    /// <returns>An array of the created entities.</returns>
+    public void CreateEntities(Span<Entity> entities, ComponentSet set)
+    {
+        var hash = set.GetHashCode();
+        var arcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(hash);
+
+        if (arcID.IsInvalid)
+        {
+            arcID = _world.ComponentManager.CreateArchetype(set.Components, hash);
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(arcID);
+
+        for (var i = 0; i < entities.Length; i++)
+        {
+            archetype.AllocateEntity(out var chunkIndex, out var rowIndex);
+
+            var id = _entityLocations.Add(new EntityLocation
+            {
+                archetypeID = arcID,
+                chunkIndex = chunkIndex,
+                rowIndex = rowIndex
+            }, out var generation);
+
+            var entity = new Entity(id, generation);
+            archetype.SetEntity(chunkIndex, rowIndex, entity);
+
+            entities[i] = entity;
+        }
+    }
+
+    /// <summary>
+    /// Create multiple entities with specified components.
+    /// </summary>
+    /// <param name="count">The number of entities to create.</param>
+    /// <param name="set">A set of component space IDs to add to the entities.</param>
+    public void CreateEntities(int count, ComponentSet set)
+    {
+        var hash = set.GetHashCode();
+        var arcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(hash);
+
+        if (arcID.IsInvalid)
+        {
+            arcID = _world.ComponentManager.CreateArchetype(set.Components, hash);
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(arcID);
+
+        for (var i = 0; i < count; i++)
+        {
+            archetype.AllocateEntity(out var chunkIndex, out var rowIndex);
+
+            var id = _entityLocations.Add(new EntityLocation
+            {
+                archetypeID = arcID,
+                chunkIndex = chunkIndex,
+                rowIndex = rowIndex
+            }, out var generation);
+
+            var entity = new Entity(id, generation);
+            archetype.SetEntity(chunkIndex, rowIndex, entity);
+        }
+    }
+
+    private void DestoryManagedEntityIfExists(ref readonly Archetype archetype, EntityLocation location)
+    {
+        var pManagedRef = archetype.GetComponentData(location.chunkIndex, location.rowIndex, ComponentTypeID<ManagedEntityRef>.Value);
+        if (pManagedRef != null)
+        {
+            DestroyManagedEntity(((ManagedEntityRef*)pManagedRef)->entity);
+        }
+    }
+
+    /// <summary>
+    /// Destroy the specified entity.
+    /// </summary>
+    /// <returns>The result status of the operation.</returns>
+    public Error DestroyEntity(Entity entity)
+    {
+        if (!_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return Error.NotFound;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+
+        DestoryManagedEntityIfExists(in archetype, location);
+        var r = archetype.RemoveEntity(location.chunkIndex, location.rowIndex);
+        if (r != Error.None)
+        {
+            return r;
+        }
+
+        if (!_entityLocations.Remove(entity.ID, entity.Generation))
+        {
+            return Error.NotFound;
+        }
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Destroy the specified entities.
+    /// </summary>
+    /// <param name="entities">The entities to destroy.</param>
+    public void DestroyEntities(ReadOnlySpan<Entity> entities)
+    {
+        void RemoveManagedEntity(ReadOnlySpan<int> rowIndicesCache, ref readonly Archetype archetype, int chunkIndex)
+        {
+            for (var j = 0; j < rowIndicesCache.Length; j++)
+            {
+                var rowIndex = rowIndicesCache[j];
+                var location = new EntityLocation
+                {
+                    archetypeID = archetype.ID,
+                    chunkIndex = chunkIndex,
+                    rowIndex = rowIndex
+                };
+
+                DestoryManagedEntityIfExists(in archetype, location);
+            }
+        }
+
+        if (entities.Length == 0)
+        {
+            return;
+        }
+
+        using var scope = AllocationManager.CreateStackScope();
+        var batchDestroy = new UnsafeList<EntityLocation>(entities.Length, scope.AllocationHandle);
+        var rowIndicesCache = new UnsafeList<int>(32, scope.AllocationHandle);
+
+        // 1. GATHER
+        // Resolve all entities to their locations
+        for (var i = 0; i < entities.Length; i++)
+        {
+            var entity = entities[i];
+            if (_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+            {
+                batchDestroy.Add(location);
+            }
+        }
+
+        if (batchDestroy.Count == 0)
+        {
+            return;
+        }
+
+        // 2. SORT
+        // Sorting groups them by chunk automatically
+        batchDestroy.AsSpan().Sort();
+
+        // 3. SWEEP
+        // Iterate through the sorted list and batch process each chunk
+        var firstLoc = batchDestroy[0];
+        var prevArchetypeID = firstLoc.archetypeID;
+        var prevChunkIndex = firstLoc.chunkIndex;
+
+        for (var i = 0; i < batchDestroy.Count; i++)
+        {
+            var loc = batchDestroy[i];
+
+            // Check if we have crossed a boundary (Different Chunk OR Different Archetype)
+            var isNewBatch = (loc.chunkIndex != prevChunkIndex) || (loc.archetypeID != prevArchetypeID);
+
+            if (isNewBatch)
+            {
+                // FLUSH PREVIOUS BATCH
+                // We must retrieve the Archetype of the *Previous* batch, not the current 'loc'
+                ref var prevArchetype = ref _world.ComponentManager.GetArchetypeReference(prevArchetypeID);
+
+                // Remove Managed Entities first
+                RemoveManagedEntity(rowIndicesCache.AsSpan(), in prevArchetype, prevChunkIndex);
+
+                // Execute the hole-filling/swap logic
+                prevArchetype.RemoveEntities(prevChunkIndex, rowIndicesCache.AsSpan());
+
+                // RESET
+                rowIndicesCache.Clear();
+                prevArchetypeID = loc.archetypeID;
+                prevChunkIndex = loc.chunkIndex;
+            }
+
+            rowIndicesCache.Add(loc.rowIndex);
+        }
+
+        // 4. FINAL FLUSH
+        // Process the stragglers remaining in the cache
+        if (rowIndicesCache.Count > 0)
+        {
+            ref var lastArchetype = ref _world.ComponentManager.GetArchetypeReference(prevArchetypeID);
+
+            RemoveManagedEntity(rowIndicesCache.AsSpan(), in lastArchetype, prevChunkIndex);
+            lastArchetype.RemoveEntities(prevChunkIndex, rowIndicesCache.AsSpan());
+        }
+
+        // 5. Remove from Entity Locations
+        for (var i = 0; i < entities.Length; i++)
+        {
+            var entity = entities[i];
+            _entityLocations.Remove(entity.ID, entity.Generation);
+        }
+    }
+
+    /// <summary>
+    /// Check if the specified entity exists.
+    /// </summary>
+    /// <param name="entity">The entity to check.</param>
+    /// <returns>True if the entity exists, false otherwise.</returns>
+    public bool Exists(Entity entity)
+    {
+        return _entityLocations.Contains(entity.ID, entity.Generation);
+    }
+
+    /// <summary>
+    /// Create a singleton entity with the specified component.
+    /// </summary>
+    /// <param name="componentID">The component space ID of the singleton.</param>
+    /// <param name="pComponent">Pointer to the component data.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error CreateSingleton(Identifier<IComponent> componentID, void* pComponent)
+    {
+        if (pComponent == null)
+        {
+            return Error.InvalidArgument;
+        }
+
+        // Check if singleton already exists
+        var signatureHash = ComponentRegistry.GetHashCode(componentID);
+        var arcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(signatureHash);
+
+        if (arcID.IsValid)
+        {
+            return Error.InvalidArgument;
+        }
+
+        arcID = _world.ComponentManager.CreateArchetype([componentID], signatureHash);
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(arcID);
+        archetype.AllocateEntity(out var chunkIndex, out var rowIndex);
+
+        var id = _entityLocations.Add(new EntityLocation
+        {
+            archetypeID = arcID,
+            chunkIndex = chunkIndex,
+            rowIndex = rowIndex
+        }, out var generation);
+
+        var entity = new Entity(id, generation);
+        archetype.SetEntity(chunkIndex, rowIndex, entity);
+        archetype.SetComponentData(chunkIndex, rowIndex, componentID, pComponent);
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Create a singleton entity with the specified component.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="component">The component data.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error CreateSingleton<T>(T component = default)
+        where T : unmanaged, IComponent
+    {
+        return CreateSingleton(ComponentTypeID<T>.Value, &component);
+    }
+
+    /// <summary>
+    /// Get a pointer to the singleton component data.
+    /// </summary>
+    /// <param name="componentID">The component space ID of the singleton.</param>
+    /// <returns>Pointer to the component data, or null if not found.</returns>
+    public void* GetSingleton(Identifier<IComponent> componentID)
+    {
+        var signatureHash = ComponentRegistry.GetHashCode(componentID);
+        var arcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(signatureHash);
+
+        if (arcID.IsInvalid)
+        {
+            return null;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(arcID);
+        var layoutResult = archetype.GetLayout(componentID);
+        if (layoutResult.Error != Error.None)
+        {
+            return null;
+        }
+
+        var chunk = archetype._chunks[0];
+        var ptr = chunk.GetUnsafePtr() + layoutResult.Value.offset;
+
+        return ptr;
+    }
+
+    /// <summary>
+    /// Get a reference to the singleton component data.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <returns>Reference to the component data. null ref if not found.</returns>
+    public ref T GetSingleton<T>()
+        where T : unmanaged, IComponent
+    {
+        var ptr = GetSingleton(ComponentTypeID<T>.Value);
+        return ref *(T*)ptr; // This will return null ref if ptr is null.
+    }
+
+    private static void CopyData(ref Archetype oldArch, int oldChunk, int oldRow,
+                                 ref Archetype newArch, int newChunk, int newRow)
+    {
+        // Iterate every component space in the OLD archetype
+        for (var i = 0; i < oldArch._layouts.Count; i++)
+        {
+            var layout = oldArch._layouts[i];
+
+            var src = oldArch._chunks[oldChunk].GetUnsafePtr() + layout.offset + (layout.size * oldRow);
+            var r = newArch.GetLayout(layout.componentID);
+            if (r.Error != Error.None)
+            {
+                // New archetype does not have this component, skip it.
+                // This can happen when removing components.
+                continue;
+            }
+
+            var dst = newArch._chunks[newChunk].GetUnsafePtr() + r.Value.offset + (layout.size * newRow);
+
+            MemoryUtility.MemCpy(dst, src, (nuint)layout.size);
+        }
+    }
+
+    /// <summary>
+    /// Add a component to the specified entity.
+    /// </summary>
+    /// <param name="entity">The entity to add the component to.</param>
+    /// <param name="componentID">The component space ID to add.</param>
+    /// <param name="pComponent">Pointer to the component data.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error AddComponent(Entity entity, Identifier<IComponent> componentID, void* pComponent)
+    {
+        // Find current location
+        ref var location = ref _entityLocations.GetElementReferenceAt(entity.ID, entity.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        // Build new archetype signature
+        ref var oldArchetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        var oldSignature = oldArchetype._signature;
+
+        if (oldSignature.IsSet(componentID))
+        {
+            // Component already exists
+            return Error.InvalidArgument;
+        }
+
+        var newArcID = oldArchetype.GetEdgeAdd(componentID);
+        if (newArcID.IsInvalid)
+        {
+            var largestComponentID = Math.Max(oldSignature.Count, componentID);
+            var length = UnsafeBitSet.RequiredLength(largestComponentID + 1);
+
+            Span<uint> bits = stackalloc uint[length];
+            bits.Clear();
+
+            var newSignature = new SpanBitSet(bits);
+
+            var oldIt = oldSignature.GetIterator();
+            var compCount = 0;
+            while (oldIt.Next(out var index))
+            {
+                newSignature.SetBit(index);
+                compCount++;
+            }
+
+            compCount++;
+            newSignature.SetBit(componentID);
+
+            // Find or create new archetype
+            var newSignatureHash = newSignature.GetHashCode();
+            newArcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(newSignatureHash);
+            if (newArcID.IsInvalid)
+            {
+                // Create new archetype
+                Span<Identifier<IComponent>> componentTypeIDs = stackalloc Identifier<IComponent>[compCount];
+
+                var newIt = newSignature.GetIterator();
+                var i = 0;
+                while (newIt.Next(out var index))
+                {
+                    componentTypeIDs[i++] = index;
+                }
+
+                newArcID = _world.ComponentManager.CreateArchetype(componentTypeIDs, newSignatureHash);
+            }
+
+            oldArchetype.AddEdgeAdd(componentID, newArcID);
+        }
+
+        // Move entity data
+        ref var newArchetype = ref _world.ComponentManager.GetArchetypeReference(newArcID);
+        newArchetype.AllocateEntity(out var newChunkIndex, out var newRowIndex);
+        CopyData(ref oldArchetype, location.chunkIndex, location.rowIndex,
+                 ref newArchetype, newChunkIndex, newRowIndex);
+
+        newArchetype.SetEntity(newChunkIndex, newRowIndex, entity);
+        newArchetype.SetComponentData(newChunkIndex, newRowIndex, componentID, pComponent);
+
+        var r = oldArchetype.RemoveEntity(location.chunkIndex, location.rowIndex);
+        Debug.Assert(r == Error.None); // We assert it because the entity should exist if the whole system is consistent.
+        if (r != Error.None)
+        {
+            return r;
+        }
+
+        // Update location
+        location.archetypeID = newArcID;
+        location.chunkIndex = newChunkIndex;
+        location.rowIndex = newRowIndex;
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Add a component to the specified entity.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="entity">The entity to add the component to.</param>
+    /// <param name="component">The component data.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error AddComponent<T>(Entity entity, T component = default)
+        where T : unmanaged, IComponent
+    {
+        return AddComponent(entity, ComponentTypeID<T>.Value, &component);
+    }
+
+    /// <summary>
+    /// Remove a component from the specified entity.
+    /// </summary>
+    /// <param name="entity">The entity to remove the component from.</param>
+    /// <param name="componentID">The component space ID to remove.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error RemoveComponent(Entity entity, Identifier<IComponent> componentID)
+    {
+        // Find current location
+        ref var location = ref _entityLocations.GetElementReferenceAt(entity.ID, entity.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        // Build new archetype signature
+        ref var oldArchetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        var oldSignature = oldArchetype._signature;
+
+        var newArcID = oldArchetype.GetEdgeRemove(componentID);
+        if (newArcID.IsInvalid)
+        {
+            var largestComponentID = Math.Max(oldSignature.Count, componentID);
+            var length = UnsafeBitSet.RequiredLength(largestComponentID + 1);
+
+            Span<uint> bits = stackalloc uint[length];
+            bits.Clear();
+
+            var newSignature = new SpanBitSet(bits);
+
+            var oldIt = oldSignature.GetIterator();
+            var compCount = 0;
+            while (oldIt.Next(out var index))
+            {
+                if (index != componentID)
+                {
+                    newSignature.SetBit(index);
+                    compCount++;
+                }
+            }
+
+            // Find or create new archetype
+            var newSignatureHash = newSignature.GetHashCode();
+            newArcID = _world.ComponentManager.GetArchetypeIDBySignatureHash(newSignatureHash);
+            if (newArcID.IsInvalid)
+            {
+                // Create new archetype
+                Span<Identifier<IComponent>> componentTypeIDs = stackalloc Identifier<IComponent>[compCount];
+
+                var newIt = newSignature.GetIterator();
+                var i = 0;
+                while (newIt.Next(out var index))
+                {
+                    componentTypeIDs[i++] = index;
+                }
+
+                newArcID = _world.ComponentManager.CreateArchetype(componentTypeIDs, newSignatureHash);
+            }
+
+            oldArchetype.AddEdgeRemove(componentID, newArcID);
+        }
+
+        // Move entity data
+        ref var newArchetype = ref _world.ComponentManager.GetArchetypeReference(newArcID);
+        newArchetype.AllocateEntity(out var newChunkIndex, out var newRowIndex);
+        CopyData(ref oldArchetype, location.chunkIndex, location.rowIndex,
+                 ref newArchetype, newChunkIndex, newRowIndex);
+
+        newArchetype.SetEntity(newChunkIndex, newRowIndex, entity);
+
+        var r = oldArchetype.RemoveEntity(location.chunkIndex, location.rowIndex);
+        Debug.Assert(r == Error.None); // We assert it because the entity should exist if the whole system is consistent.
+        if (r != Error.None)
+        {
+            return r;
+        }
+
+        var pManagedRef = oldArchetype.GetComponentData(location.chunkIndex, location.rowIndex, ComponentTypeID<ManagedEntityRef>.Value);
+        if (pManagedRef != null)
+        {
+            DestroyManagedEntity(((ManagedEntityRef*)pManagedRef)->entity);
+        }
+
+        // Update location
+        location.archetypeID = newArcID;
+        location.chunkIndex = newChunkIndex;
+        location.rowIndex = newRowIndex;
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Remove a component from the specified entity.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="entity">The entity to remove the component from.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error RemoveComponent<T>(Entity entity)
+        where T : unmanaged, IComponent
+    {
+        return RemoveComponent(entity, ComponentTypeID<T>.Value);
+    }
+
+    /// <summary>
+    /// Set the component data for the specified entity.
+    /// </summary>
+    /// <param name="entity">The entity to set the component data for.</param>
+    /// <param name="componentID">The component space ID to set.</param>
+    /// <param name="pComponent">Pointer to the component data.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error SetComponent(Entity entity, Identifier<IComponent> componentID, void* pComponent)
+    {
+        if (!_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return Error.NotFound;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        archetype.SetComponentData(location.chunkIndex, location.rowIndex, componentID, pComponent);
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Set the component data for the specified entity.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="entity">The entity to set the component data for.</param>
+    /// <param name="component">The component data.</param>
+    public Error SetComponent<T>(Entity entity, T component)
+        where T : unmanaged, IComponent
+    {
+        return SetComponent(entity, ComponentTypeID<T>.Value, &component);
+    }
+
+    /// <summary>
+    /// Get a pointer to the component data for the specified entity.
+    /// </summary>
+    /// <param name="entity">The entity to get the component data for.</param>
+    /// <param name="componentID">The component space ID to get.</param>
+    /// <returns>Pointer to the component data, or null if not found.</returns>
+    public void* GetComponent(Entity entity, Identifier<IComponent> componentID)
+    {
+        if (!_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return null;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        return archetype.GetComponentData(location.chunkIndex, location.rowIndex, componentID);
+    }
+
+    /// <summary>
+    /// Get a reference to the component data for the specified entity.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="entity">The entity to get the component data for.</param>
+    /// <returns>Reference to the component data. null ref if not found.</returns>
+    public ref T GetComponent<T>(Entity entity)
+        where T : unmanaged, IComponent
+    {
+        var ptr = GetComponent(entity, ComponentTypeID<T>.Value);
+        return ref *(T*)ptr; // This will return null ref if ptr is null.
+    }
+
+    /// <summary>
+    /// Check if the specified entity has the specified component.
+    /// </summary>
+    /// <param name="entity">The entity to check.</param>
+    /// <param name="componentID">The component space ID to check.</param>
+    /// <returns>True if the entity has the component, false otherwise.</returns>
+    public bool HasComponent(Entity entity, Identifier<IComponent> componentID)
+    {
+        if (!_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return false;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        return archetype.HasComponent(componentID);
+    }
+
+    /// <summary>
+    /// Check if the specified entity has the specified component.
+    /// </summary>
+    /// <typeparam name="T">The component space.</typeparam>
+    /// <param name="entity">The entity to check.</param>
+    /// <returns>True if the entity has the component, false otherwise.</returns>
+    public bool HasComponent<T>(Entity entity)
+        where T : unmanaged, IComponent
+    {
+        return HasComponent(entity, ComponentTypeID<T>.Value);
+    }
+
+    /// <summary>
+    /// Set the enabled state of an enableable component for the specified entity.
+    /// </summary>
+    /// <param name="entity">The entity to set the enabled state for.</param>
+    /// <param name="componentID">The component space ID of the enableable component.</
+    /// <param name="enabled">True to enable the component, false to disable it.</param>
+    /// <returns>The result status of the operation.</returns>
+    public Error SetEnabled(Entity entity, Identifier<IComponent> componentID, bool enabled)
+    {
+        if (!_entityLocations.TryGetElementAt(entity.ID, entity.Generation, out var location))
+        {
+            return Error.NotFound;
+        }
+
+        ref var archetype = ref _world.ComponentManager.GetArchetypeReference(location.archetypeID);
+        var chunkIndex = location.chunkIndex;
+        var rowIndex = location.rowIndex;
+
+        var layoutResult = archetype.GetLayout(componentID);
+        if (layoutResult.Error != Error.None)
+        {
+            return layoutResult.Error;
+        }
+
+        ref var chunk = ref archetype.GetChunkReference(chunkIndex);
+        var chunkBase = chunk.GetUnsafePtr();
+        var maskBase = chunkBase + layoutResult.Value.enableBitsOffset;
+
+        var byteIndex = rowIndex >> Chunk.BIT_SHIFT;
+        var bitIndex = rowIndex & Chunk.BIT_ALIGNMENT_MINUS_ONE;
+
+        if (enabled)
+        {
+            maskBase[byteIndex] |= (byte)(1 << bitIndex);
+        }
+        else
+        {
+            maskBase[byteIndex] &= (byte)~(1 << bitIndex);
+        }
+
+        return Error.None;
+    }
+
+    /// <summary>
+    /// Set the enabled state of an enableable component for the specified entity.
+    /// </summary>
+    /// <typeparam name="T">The enableable component space.</typeparam>
+    /// <param name="entity">The entity to set the enabled state for.</param>
+    /// <param name="enabled">True to enable the component, false to disable it.</
+    /// <returns>The result status of the operation.</returns>
+    public Error SetEnabled<T>(Entity entity, bool enabled)
+        where T : unmanaged, IEnableableComponent
+    {
+        return SetEnabled(entity, ComponentTypeID<T>.Value, enabled);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _entityLocations.Dispose();
+        _disposed = true;
+
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Entities/EntityQuery.JobChunk.cs

@@ -0,0 +1,96 @@
+using Ghost.Core;
+using Misaki.HighPerformance.Jobs;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public interface IJobChunk
+{
+    void Execute(ChunkView view, int threadIndex);
+}
+
+internal unsafe struct ChunkInfo
+{
+    public Chunk* pChunk;
+    public Archetype* pArchetype;
+}
+
+internal unsafe struct JobChunkBatch<TJob> : IJobParallelFor
+    where TJob : unmanaged, IJobChunk
+{
+
+    public TJob userJob;
+    public ReadOnlyUnsafeCollection<ChunkInfo> chunkInfos;
+
+    public void Execute(int loopIndex, int threadIndex)
+    {
+        var info = chunkInfos[loopIndex];
+        var view = new ChunkView(in *info.pArchetype, in *info.pChunk);
+
+        userJob.Execute(view, threadIndex);
+    }
+}
+
+internal struct DisposeJobChunk : IJob
+{
+    public UnsafeList<ChunkInfo> list;
+
+    public void Execute(int threadIndex)
+    {
+        list.Dispose();
+    }
+}
+
+public unsafe partial struct EntityQuery
+{
+    public JobHandle ScheduleChunkParallel<TJob>(TJob job, int batchSize, JobHandle dependency)
+        where TJob : unmanaged, IJobChunk
+    {
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return JobHandle.Invalid;
+        }
+
+        if (world.JobScheduler == null)
+        {
+            throw new InvalidOperationException("The World has no JobScheduler assigned.");
+        }
+
+        var chunkInfos = new UnsafeList<ChunkInfo>(_matchingArchetypes.Count * 2, JobScheduler.TempAllocatorHandle);
+
+        foreach (var archID in _matchingArchetypes)
+        {
+            ref var arch = ref world.ComponentManager.GetArchetypeReference(archID);
+
+            for (int i = 0; i < arch.ChunkCount; i++)
+            {
+                var pChunk = (Chunk*)arch._chunks.GetUnsafePtr() + i;
+
+                chunkInfos.Add(new ChunkInfo
+                {
+                    pArchetype = (Archetype*)Unsafe.AsPointer(ref arch),
+                    pChunk = pChunk
+                });
+            }
+        }
+
+        var batchJob = new JobChunkBatch<TJob>
+        {
+            userJob = job,
+            chunkInfos = chunkInfos.AsReadOnly()
+        };
+
+        var handle = world.JobScheduler.ScheduleParallel(ref batchJob, chunkInfos.Count, batchSize, dependency);
+
+        var disposeJob = new DisposeJobChunk
+        {
+            list = chunkInfos
+        };
+
+        world.JobScheduler.Schedule(ref disposeJob, handle);
+
+        return handle;
+    }
+}

src/Runtime/Ghost.Entities/Ghost.Entities.csproj

@@ -0,0 +1,88 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <IsAotCompatible>False</IsAotCompatible>
+    <IsTrimmable>False</IsTrimmable>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="Templates\EntityQuery.ForEach.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>EntityQuery.ForEach.tt</DependentUpon>
+    </None>
+    <None Include="Templates\ForEach.gen.cs">
+      <DependentUpon>ForEach.tt</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </None>
+    <None Include="Templates\QueryBuilder.With.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>QueryBuilder.With.tt</DependentUpon>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Ghost.Core\Ghost.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Templates\EntityQuery.ForEach.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>EntityQuery.ForEach.gen.cs</LastGenOutput>
+    </None>
+    <None Update="Templates\ForEach.tt">
+      <LastGenOutput>ForEach.gen.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Templates\EntityQuery.JobEntityParallel.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>EntityQuery.JobEntityParallel.gen.cs</LastGenOutput>
+    </None>
+    <None Update="Templates\QueryBuilder.With.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>QueryBuilder.With.gen.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Templates\EntityQuery.ForEach.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>EntityQuery.ForEach.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Templates\EntityQuery.JobEntityParallel.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>EntityQuery.JobEntityParallel.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Templates\ForEach.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ForEach.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Templates\QueryBuilder.With.gen.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>QueryBuilder.With.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+</Project>

src/Runtime/Ghost.Entities/ManagedComponent.cs

@@ -0,0 +1,256 @@
+#if false
+using Ghost.Core;
+using Misaki.HighPerformance.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public interface IManagedComponent;
+public interface IManagedWrapper;
+
+public readonly struct Managed<T> : IComponent, IManagedWrapper
+    where T : IManagedComponent
+{
+    public readonly int id;
+    public readonly int generation;
+
+    internal Managed(int id, int generation)
+    {
+        this.id = id;
+        this.generation = generation;
+    }
+}
+
+public static class ManagedComponemtnID<T>
+    where T : IManagedComponent
+{
+    public static readonly Identifier<IManagedComponent> value = ManagedComponentRegistry.GetOrRegisterComponent<T>();
+}
+
+internal struct ManagedComponentInfo
+{
+    public int id;
+    public bool isScriptComponent;
+}
+
+internal static class ManagedComponentRegistry
+{
+    private static readonly List<ManagedComponentInfo> s_registeredComponents = new();
+    private static readonly Dictionary<IntPtr, int> s_typeHandleToID = new();
+    private static readonly Dictionary<string, int> s_nameToRuntimeID = new();
+#if DEBUG || GHOST_EDITOR
+    internal static readonly Dictionary<int, Type> s_runtimeIDToType = new();
+#endif
+
+    public static Identifier<IManagedComponent> GetOrRegisterComponent<T>()
+        where T : IManagedComponent
+    {
+        var typeHandle = typeof(T).TypeHandle.Value;
+
+        lock (s_registeredComponents)
+        {
+            if (s_typeHandleToID.TryGetValue(typeHandle, out var existingID))
+            {
+                return existingID;
+            }
+
+            var newID = new Identifier<IManagedComponent>(s_registeredComponents.Count);
+            var stableName = typeof(T).FullName ?? typeof(T).Name;
+            var info = new ManagedComponentInfo
+            {
+                id = newID,
+                isScriptComponent = typeof(ScriptComponent).IsAssignableFrom(typeof(T)),
+            };
+
+            s_registeredComponents.Add(info);
+
+            s_typeHandleToID[typeHandle] = newID;
+            s_nameToRuntimeID[stableName] = newID;
+#if DEBUG || GHOST_EDITOR
+            s_runtimeIDToType[newID.value] = typeof(T);
+#endif
+
+            return newID;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Identifier<IManagedComponent> GetComponentID(Type type)
+    {
+        var typeHandle = type.TypeHandle.Value;
+        lock (s_registeredComponents)
+        {
+            if (s_typeHandleToID.TryGetValue(typeHandle, out var existingID))
+            {
+                return existingID;
+            }
+        }
+
+        return Identifier<IManagedComponent>.Invalid;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ManagedComponentInfo GetComponentInfo(Identifier<IManagedComponent> typeId)
+    {
+        lock (s_registeredComponents)
+        {
+            return s_registeredComponents[typeId];
+        }
+    }
+}
+
+internal interface IManagedComponentStorage
+{
+    public Identifier<IManagedComponent> TypeID { get; }
+}
+
+internal class ManagedComponentStorage<T> : IManagedComponentStorage
+    where T : IManagedComponent
+{
+    private readonly SlotMap<T> _storage = new(16);
+
+    public Identifier<IManagedComponent> TypeID => ManagedComponemtnID<T>.value;
+
+    public Managed<T> Add(T component)
+    {
+        var id = _storage.Add(component, out var generation);
+        return new Managed<T>(id, generation);
+    }
+
+    public void Remove(Managed<T> managed)
+    {
+        _storage.Remove(managed.id, managed.generation);
+    }
+
+    public ref T GetComponentReference(Managed<T> managed)
+    {
+        return ref _storage.GetElementReferenceAt(managed.id, managed.generation, out _);
+    }
+}
+
+public abstract class ScriptComponent : IManagedComponent
+{
+    internal World _world = null!;
+    internal Entity _entity;
+
+    public World World => _world;
+    public Entity Entity => _entity;
+
+    protected ref T GetComponent<T>()
+        where T : unmanaged, IComponent
+    {
+        return ref _world.EntityManager.GetComponent<T>(_entity);
+    }
+
+    public virtual void OnCreate()
+    {
+    }
+
+    public virtual void OnDestroy()
+    {
+    }
+
+    public virtual void OnEnable()
+    {
+    }
+
+    public virtual void OnDisable()
+    {
+    }
+
+    public virtual void Start()
+    {
+    }
+
+    public virtual void Update()
+    {
+    }
+
+    public virtual void FixedUpdate()
+    {
+    }
+
+    public virtual void LateUpdate()
+    {
+    }
+}
+
+public partial class EntityManager
+{
+    private IManagedComponentStorage[] _storages;
+
+    internal IManagedComponentStorage[] Storages => _storages;
+
+    private ManagedComponentStorage<T> GetOrCreateManagedComponentStorage<T>()
+        where T : IManagedComponent
+    {
+        var id = ManagedComponemtnID<T>.value;
+        if (_storages == null || _storages.Length <= id.value)
+        {
+            Array.Resize(ref _storages, id.value + 1);
+        }
+
+        ref var storage = ref _storages[id.value];
+        storage ??= new ManagedComponentStorage<T>();
+
+        return (ManagedComponentStorage<T>)storage;
+    }
+
+    public Managed<T> AddManagedComponent<T>(Entity entity)
+        where T : IManagedComponent, new()
+    {
+        var instance = new T();
+        if (instance is ScriptComponent scriptComponent)
+        {
+            scriptComponent._world = _world;
+            scriptComponent._entity = entity;
+            scriptComponent.OnCreate();
+        }
+
+        var managed = GetOrCreateManagedComponentStorage<T>().Add(instance);
+        AddComponent(entity, managed);
+
+        return managed;
+    }
+
+    public bool RemoveManagedComponent<T>(Entity entity)
+        where T : IManagedComponent
+    {
+        ref var component = ref GetComponent<Managed<T>>(entity);
+        if (!Unsafe.IsNullRef(ref component))
+        {
+            var storage = GetOrCreateManagedComponentStorage<T>();
+            var componentRef = storage.GetComponentReference(component);
+            if (componentRef is ScriptComponent scriptComponent)
+            {
+                scriptComponent.OnDestroy();
+            }
+
+            RemoveComponent<Managed<T>>(entity);
+            storage.Remove(component);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public ref T GetManagedComponent<T>(Entity entity)
+        where T : IManagedComponent
+    {
+        ref var component = ref GetComponent<Managed<T>>(entity);
+        if (Unsafe.IsNullRef(ref component))
+        {
+            return ref Unsafe.NullRef<T>();
+        }
+
+        return ref GetOrCreateManagedComponentStorage<T>().GetComponentReference(component);
+    }
+
+    public ref T GetManagedComponent<T>(Managed<T> managedComponent)
+        where T : IManagedComponent
+    {
+        return ref GetOrCreateManagedComponentStorage<T>().GetComponentReference(managedComponent);
+    }
+}
+#endif

src/Runtime/Ghost.Entities/ManagedEntity.cs

@@ -0,0 +1,69 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public record struct ManagedEntity
+{
+    public int id;
+    public int generation;
+}
+
+public struct ManagedEntityRef : IComponent
+{
+    public ManagedEntity entity;
+}
+
+public abstract class ScriptComponent
+{
+    internal World _world = null!;
+    internal Entity _entity;
+    internal ManagedEntity _managedEntity;
+
+    public World World => _world;
+    public Entity Entity => _entity;
+    public ManagedEntity ManagedEntity => _managedEntity;
+
+    protected ref T GetComponent<T>()
+        where T : unmanaged, IComponent
+    {
+        ref var value = ref _world.EntityManager.GetComponent<T>(_entity);
+        if (Unsafe.IsNullRef(ref value))
+        {
+            throw new InvalidOperationException($"Entity {_entity} does not have component of type {typeof(T)}");
+        }
+
+        return ref value;
+    }
+
+    public virtual void OnCreate()
+    {
+    }
+
+    public virtual void OnDestroy()
+    {
+    }
+
+    public virtual void OnEnable()
+    {
+    }
+
+    public virtual void OnDisable()
+    {
+    }
+
+    public virtual void Start()
+    {
+    }
+
+    public virtual void Update()
+    {
+    }
+
+    public virtual void FixedUpdate()
+    {
+    }
+
+    public virtual void LateUpdate()
+    {
+    }
+}

src/Runtime/Ghost.Entities/Query.cs

@@ -0,0 +1,646 @@
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+internal struct EntityQueryMask : IDisposable, IEquatable<EntityQueryMask>
+{
+    public UnsafeBitSet structuralAll;
+    public UnsafeBitSet structuralAny;
+    public UnsafeBitSet structuralAbsent;
+
+    public UnsafeBitSet requireEnabled;
+    public UnsafeBitSet requireDisabled;
+    public UnsafeBitSet rejectIfEnabled;
+
+    public UnsafeBitSet writeAccess;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool Matches(ref readonly UnsafeBitSet archetypeSignature)
+    {
+        return (!structuralAll.IsCreated || structuralAll.All(archetypeSignature))
+            && (!structuralAbsent.IsCreated || structuralAbsent.None(archetypeSignature))
+            && (!structuralAny.IsCreated || structuralAny.Count == 0 || structuralAny.Any(archetypeSignature));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override readonly int GetHashCode()
+    {
+        var hash = 17;
+        if (structuralAll.IsCreated) hash = hash * 23 + structuralAll.GetHashCode();
+        if (structuralAbsent.IsCreated) hash = hash * 23 + structuralAbsent.GetHashCode();
+        if (structuralAny.IsCreated) hash = hash * 23 + structuralAny.GetHashCode();
+        if (requireEnabled.IsCreated) hash = hash * 23 + requireEnabled.GetHashCode();
+        if (requireDisabled.IsCreated) hash = hash * 23 + requireDisabled.GetHashCode();
+        if (rejectIfEnabled.IsCreated) hash = hash * 23 + rejectIfEnabled.GetHashCode();
+        if (writeAccess.IsCreated) hash = hash * 23 + writeAccess.GetHashCode();
+
+        return hash;
+    }
+
+    public readonly bool Equals(EntityQueryMask other)
+    {
+        return structuralAll.Equals(other.structuralAll)
+            && structuralAny.Equals(other.structuralAny)
+            && structuralAbsent.Equals(other.structuralAbsent)
+            && requireEnabled.Equals(other.requireEnabled)
+            && requireDisabled.Equals(other.requireDisabled)
+            && rejectIfEnabled.Equals(other.rejectIfEnabled)
+            && writeAccess.Equals(other.writeAccess);
+    }
+
+    public override readonly bool Equals(object? obj)
+    {
+        return obj is EntityQueryMask mask && Equals(mask);
+    }
+
+    public static bool operator ==(EntityQueryMask left, EntityQueryMask right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(EntityQueryMask left, EntityQueryMask right)
+    {
+        return !(left == right);
+    }
+
+    public void Dispose()
+    {
+        structuralAll.Dispose();
+        structuralAny.Dispose();
+        structuralAbsent.Dispose();
+
+        requireEnabled.Dispose();
+        requireDisabled.Dispose();
+        rejectIfEnabled.Dispose();
+
+        writeAccess.Dispose();
+    }
+}
+
+/// <summary>
+/// Provides a read-only view over a chunk of entities and their component data within an archetype.
+/// </summary>
+/// <remarks>This does not filter disabled/enabled components. You must handle that manually.</remarks>
+public readonly unsafe ref struct ChunkView
+{
+    // We flatten all the information we need for fast access.
+    private readonly ReadOnlyUnsafeCollection<Archetype.ComponentMemoryLayout> _layouts;
+    private readonly ReadOnlyUnsafeCollection<int> _layoutIndexLookup;
+    private readonly byte* _pChunkData;
+    private readonly int* _pVersion;
+    private readonly int _entityOffset;
+    private readonly int _entityCount;
+    private readonly int _structuralVersion;
+    private readonly int _currentVersion;
+
+    public readonly int Count => _entityCount;
+
+    internal ChunkView(ref readonly Archetype archetype, ref readonly Chunk chunk)
+    {
+        _layouts = archetype._layouts.AsReadOnly();
+        _layoutIndexLookup = archetype._componentIDToLayoutIndex.AsReadOnly();
+        _pChunkData = chunk.GetUnsafePtr();
+        _entityOffset = archetype.EntityIDsOffset;
+        _entityCount = chunk._count;
+        _pVersion = chunk.GetVersionUnsafePtr();
+
+        _structuralVersion = chunk._structuralVersion;
+        _currentVersion = World.GetWorldUncheck(archetype.WorldID).Version;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Archetype.ComponentMemoryLayout GetLayout(Identifier<IComponent> id)
+    {
+        var index = _layoutIndexLookup[id.Value];
+        if (index == -1)
+        {
+            throw new InvalidOperationException($"Component {id} is not exist in the archetype.");
+        }
+
+        return _layouts[index];
+    }
+
+    /// <summary>
+    /// Determines whether the specified component has changed since the given version.
+    /// </summary>
+    /// <param name="id">The identifier of the component to check for changes.</param>
+    /// <param name="version">The version number to compare against the component's current version. Must be greater than or equal to zero.</param>
+    /// <returns>true if the component's current version is less than or equal to the specified version; otherwise, false.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool HasChanged(Identifier<IComponent> id, int version)
+    {
+        var layout = GetLayout(id);
+        return version < _pVersion[layout.versionIndex];
+    }
+
+    /// <summary>
+    /// Determines whether the specified version indicates that the component of space <typeparamref name="T"/> has
+    /// changed since the last recorded version.
+    /// </summary>
+    /// <typeparam name="T">The space of component to check for changes. Must be an unmanaged space that implements <see cref="IComponent"/>.</typeparam>
+    /// <param name="version">The version number to compare against the current version of the component.</param>
+    /// <returns>true if the component of space T has changed since the specified version; otherwise, false.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool HasChanged<T>(int version)
+        where T : unmanaged, IComponent
+    {
+        var layout = GetLayout(ComponentTypeID<T>.Value);
+        return version < _pVersion[layout.versionIndex];
+    }
+
+    /// <summary>
+    /// Determines whether the chunk's structure has changed since the specified version.
+    /// </summary>
+    /// <param name="version">The version number to compare against the chunk's structural version.</param>
+    /// <returns>true if the chunk's structure has changed since the specified version; otherwise, false.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool HasStructuralChanged(int version)
+    {
+        return version < _structuralVersion;
+    }
+
+    /// <summary>
+    /// Gets the current version number associated with the specified component identifier.
+    /// </summary>
+    /// <param name="id">The identifier of the component for which to retrieve the version number. Must reference a valid component.</param>
+    /// <returns>The version number of the specified component.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int GetComponentVersion(Identifier<IComponent> id)
+    {
+        return _pVersion[id];
+    }
+
+    /// <summary>
+    /// Gets the current version number associated with the specified component space.
+    /// </summary>
+    /// <typeparam name="T">The component space for which to retrieve the version. Must be an unmanaged space that implements <see cref="IComponent"/>.</typeparam>
+    /// <returns>The version number of the component space <typeparamref name="T"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int GetComponentVersion<T>()
+        where T : unmanaged, IComponent
+    {
+        return _pVersion[ComponentTypeID<T>.Value];
+    }
+
+    /// <summary>
+    /// Returns a read-only span containing structuralAll entities stored in the current chunk.
+    /// </summary>
+    /// <returns>A read-only span of <see cref="Entity"/> values representing the entities in the chunk.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ReadOnlySpan<Entity> GetEntities()
+    {
+        var pEntity = (Entity*)(_pChunkData + _entityOffset);
+        return new ReadOnlySpan<Entity>(pEntity, _entityCount);
+    }
+
+    /// <summary>
+    /// Gets a readonly span providing direct access to the component data of space T0 for structuralAll entities in the chunk.
+    /// </summary>
+    /// <typeparam name="T">The space of component to access. Must be an unmanaged space that implements <see cref="Component"/>.</typeparam>
+    /// <returns>A readonly span of space <see cref="{T}"/> containing the component data for each entity in the chunk.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the specified component space is not present in the archetype.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ReadOnlySpan<T> GetComponentData<T>()
+        where T : unmanaged, IComponent
+    {
+        var layout = GetLayout(ComponentTypeID<T>.Value);
+        var pComponentData = _pChunkData + layout.offset;
+        return new ReadOnlySpan<T>(pComponentData, _entityCount);
+    }
+
+    /// <summary>
+    /// Gets a span providing direct access to the component data of space T0 for structuralAll entities in the chunk.
+    /// </summary>
+    /// <typeparam name="T">The space of component to access. Must be an unmanaged space that implements <see cref="Component"/>.</typeparam>
+    /// <returns>A span of space <see cref="{T}"/> containing the component data for each entity in the chunk.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the specified component space is not present in the archetype.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Span<T> GetComponentDataRW<T>()
+        where T : unmanaged, IComponent
+    {
+        var compId = ComponentTypeID<T>.Value;
+        var layout = GetLayout(compId);
+
+        _pVersion[layout.versionIndex] = _currentVersion;
+
+        var pComponentData = _pChunkData + layout.offset;
+        return new Span<T>(pComponentData, _entityCount);
+    }
+
+    /// <summary>
+    /// Gets a bit set representing the enabled state of each instance of the specified enableable component
+    /// space within the current chunk.
+    /// </summary>
+    /// <typeparam name="T">The component space for which to retrieve enablement bits. Must be unmanaged and implement <see cref="IEnableableComponent"/>.</typeparam>
+    /// <returns>A <see cref="SpanBitSet"/> that provides access to the enablement bits for all instances of the specified component space in the chunk.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the specified component space does not support enablement.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public SpanBitSet GetEnableBits<T>()
+        where T : unmanaged, IEnableableComponent
+    {
+        var layout = _layouts[ComponentTypeID<T>.Value];
+        var maskBase = _pChunkData + layout.enableBitsOffset;
+        return new SpanBitSet(new Span<uint>(maskBase, (_entityCount + 31) / 32));
+    }
+
+    /// <summary>
+    /// Determines whether the specified component of space <typeparamref name="T"/> at the given index is currently enabled.
+    /// </summary>
+    /// <typeparam name="T">The space of the component to check. Must be an unmanaged space that implements <see cref="IEnableableComponent"/>.</typeparam>
+    /// <param name="index">The zero-based index of the component instance to check within the chunk.</param>
+    /// <returns>true if the component at the specified index is enabled; otherwise, false.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the specified component space <typeparamref name="T"/> does not support enable/disable functionality.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool IsComponentEnabled<T>(int index)
+        where T : unmanaged, IEnableableComponent
+    {
+        var layout = GetLayout(ComponentTypeID<T>.Value);
+        var pMask = _pChunkData + layout.enableBitsOffset;
+        return EntityQuery.CheckBit(pMask, index);
+    }
+}
+
+public unsafe partial struct EntityQuery : IDisposable
+{
+    /// <summary>
+    /// Provides an enumerator for iterating over chunks of entities and their component data that match a set of archetypes within a world.
+    /// </summary>
+    public readonly ref struct ChunkIterator
+    {
+        public ref struct Enumerator
+        {
+            private readonly ChunkIterator _iterator;
+            private int _archetypeIndex;
+            private int _chunkIndex;
+
+            internal Enumerator(ChunkIterator iterator)
+            {
+                _iterator = iterator;
+                _archetypeIndex = 0;
+                _chunkIndex = -1;
+            }
+
+            public readonly ChunkView Current
+            {
+                get
+                {
+                    ref var archetype = ref _iterator._world.ComponentManager.GetArchetypeReference(_iterator._matchingArchetypes[_archetypeIndex]);
+                    ref var chunk = ref archetype.GetChunkReference(_chunkIndex);
+                    return new ChunkView(in archetype, in chunk);
+                }
+            }
+
+            public bool MoveNext()
+            {
+                _chunkIndex++;
+
+                while (_archetypeIndex < _iterator._matchingArchetypes.Count)
+                {
+                    ref var archetype = ref _iterator._world.ComponentManager.GetArchetypeReference(_iterator._matchingArchetypes[_archetypeIndex]);
+                    if (_chunkIndex < archetype.ChunkCount)
+                    {
+                        return true;
+                    }
+
+                    _chunkIndex = 0;
+                    _archetypeIndex++;
+                }
+
+                return false;
+            }
+
+            public void Reset()
+            {
+                _archetypeIndex = 0;
+                _chunkIndex = -1;
+            }
+        }
+
+        private readonly ReadOnlyUnsafeCollection<Identifier<Archetype>> _matchingArchetypes;
+        private readonly World _world;
+
+        internal ChunkIterator(ReadOnlyUnsafeCollection<Identifier<Archetype>> matchingArchetypes, World world)
+        {
+            _matchingArchetypes = matchingArchetypes;
+            _world = world;
+        }
+
+        public readonly Enumerator GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+    }
+
+    internal EntityQueryMask _mask;
+
+    private UnsafeList<Identifier<Archetype>> _matchingArchetypes;
+    private readonly Identifier<EntityQuery> _id;
+    private readonly Identifier<World> _worldID;
+
+    internal EntityQuery(Identifier<EntityQuery> id, Identifier<World> worldID, EntityQueryMask mask)
+    {
+        _id = id;
+        _worldID = worldID;
+        _mask = mask;
+        _matchingArchetypes = new UnsafeList<Identifier<Archetype>>(8, Allocator.Persistent);
+    }
+
+    // TODO: Fetching layout every time is not optimal. Cache them?
+    private static bool IsEntityValid(byte* chunkBase, int entityIndex, ref readonly Archetype archetype, ref readonly EntityQueryMask mask)
+    {
+        // 1. Check "Require Enabled" (WithAll)
+        var it = mask.requireEnabled.GetIterator();
+        while (it.Next(out var id))
+        {
+            // Get the EnableBitmask for this component in this chunk
+            var layoutResult = archetype.GetLayout(id);
+            if (layoutResult.Error != Error.None
+                // Not enableable, always true
+                || layoutResult.Value.enableBitsOffset == -1)
+            {
+                continue;
+            }
+
+            // Check bit
+            if (!CheckBit(chunkBase + layoutResult.Value.enableBitsOffset, entityIndex))
+            {
+                return false;
+            }
+        }
+
+        // 2. Check "Require Disabled" (WithDisabled)
+        it = mask.requireDisabled.GetIterator();
+        while (it.Next(out var id))
+        {
+            var layoutResult = archetype.GetLayout(id);
+            if (layoutResult.Error != Error.None)
+            {
+                continue;
+            }
+
+            // If component is not enableable, it is technically "Always Enabled", 
+            // so it cannot satisfy "WithDisabled".
+
+            // Check bit (Must be 0)
+            if (layoutResult.Value.enableBitsOffset == -1
+                || CheckBit(chunkBase + layoutResult.Value.enableBitsOffset, entityIndex))
+            {
+                return false;
+            }
+        }
+
+        // 3. Check "Reject if Enabled" (The "Soft WithNone")
+        it = mask.rejectIfEnabled.GetIterator();
+        while (it.Next(out var id))
+        {
+            var layoutResult = archetype.GetLayout(id);
+            if (layoutResult.Error != Error.None)
+            {
+                continue;
+            }
+
+            // If component is not enableable, it is technically "Always Enabled", 
+            // so it cannot satisfy "Reject if Enabled".
+
+            // Check bit (Must be 0)
+            if (layoutResult.Value.enableBitsOffset == -1
+                || CheckBit(chunkBase + layoutResult.Value.enableBitsOffset, entityIndex))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static bool CheckBit(byte* maskBase, int index)
+    {
+        var byteIndex = index >> Chunk.BIT_SHIFT;
+        var bitIndex = index & Chunk.BIT_ALIGNMENT_MINUS_ONE;
+        return (maskBase[byteIndex] & (1 << bitIndex)) != 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void AddArchetypeIfMatch(ref readonly Archetype archetype)
+    {
+        if (_mask.Matches(in archetype._signature))
+        {
+            _matchingArchetypes.Add(archetype.ID);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ChunkIterator GetChunkIterator()
+    {
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return default;
+        }
+
+        return new ChunkIterator(_matchingArchetypes.AsReadOnly(), world);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly int GetEntityCount()
+    {
+        var total = 0;
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return 0;
+        }
+
+        for(var i = 0; i < _matchingArchetypes.Count; i++)
+        {
+            var archetypeID = _matchingArchetypes[i];
+            ref var archetype = ref world.ComponentManager.GetArchetypeReference(archetypeID);
+            for (var j = 0; j < archetype.ChunkCount; j++)
+            {
+                ref var chunk = ref archetype.GetChunkReference(j);
+                total += chunk._count;
+            }
+        }
+
+        return total;
+    }
+
+    public void Dispose()
+    {
+        _mask.Dispose();
+        _matchingArchetypes.Dispose();
+    }
+}
+
+public ref partial struct QueryBuilder
+{
+    private readonly Stack.Scope _scope;
+
+    private UnsafeList<Identifier<IComponent>> _all;
+    private UnsafeList<Identifier<IComponent>> _any;
+    private UnsafeList<Identifier<IComponent>> _absent;
+    private UnsafeList<Identifier<IComponent>> _none;
+    private UnsafeList<Identifier<IComponent>> _disabled;
+    private UnsafeList<Identifier<IComponent>> _present;
+
+    private UnsafeList<Identifier<IComponent>> _rw;
+
+    public QueryBuilder()
+    {
+        _scope = AllocationManager.CreateStackScope();
+
+        _all = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+        _any = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+        _absent = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+        _none = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+        _disabled = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+        _present = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+
+        _rw = new UnsafeList<Identifier<IComponent>>(4, _scope.AllocationHandle);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void FindMax(UnsafeList<Identifier<IComponent>> list, ref int max)
+    {
+        foreach (var id in list)
+        {
+            if (id.Value > max) max = id.Value;
+        }
+    }
+
+    public void WithAll(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _all.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithAny(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _any.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithAbsent(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _absent.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithNone(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _none.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithDisabled(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _disabled.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithPresent(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _present.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public void WithPresentRW(params Span<Identifier<IComponent>> componentIDs)
+    {
+        _present.AddRange(componentIDs, componentIDs.Length);
+        _rw.AddRange(componentIDs, componentIDs.Length);
+    }
+
+    public Identifier<EntityQuery> Build(World world, Allocator allocator = Allocator.Persistent)
+    {
+        // 1. Calculate max component ID to size the BitSets
+        var maxID = 0;
+        FindMax(_all, ref maxID);
+        FindMax(_any, ref maxID);
+        FindMax(_absent, ref maxID);
+        FindMax(_none, ref maxID);
+        FindMax(_disabled, ref maxID);
+        FindMax(_present, ref maxID);
+
+        // 2. Create the Mask
+        var mask = new EntityQueryMask
+        {
+            structuralAll = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+            structuralAny = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+            structuralAbsent = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+            requireEnabled = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+            requireDisabled = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+            rejectIfEnabled = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+
+            writeAccess = new UnsafeBitSet(maxID + 1, allocator, AllocationOption.Clear),
+        };
+
+        // 3. Fill BitSets
+        foreach (var id in _all)
+        {
+            mask.structuralAll.SetBit(id);  // Structure: Must Exist
+            mask.requireEnabled.SetBit(id); // Filter: Must be Enabled
+        }
+
+        foreach (var id in _disabled)
+        {
+            mask.structuralAll.SetBit(id);   // Structure: Must Exist
+            mask.requireDisabled.SetBit(id); // Filter: Must be Disabled
+        }
+
+        foreach (var id in _none)
+        {
+            if (ComponentRegistry.GetComponentInfo(id).isEnableable)
+            {
+                mask.rejectIfEnabled.SetBit(id); // Filter: Must Not be Enabled (Can be Absent or Disabled)
+            }
+            else
+            {
+                mask.structuralAbsent.SetBit(id); // Structure: Must Not Exist
+            }
+        }
+
+        foreach (var id in _present)
+        {
+            mask.structuralAll.SetBit(id);
+        }
+
+        foreach (var id in _absent)
+        {
+            mask.structuralAbsent.SetBit(id);
+        }
+
+        foreach (var id in _any)
+        {
+            mask.structuralAny.SetBit(id);
+        }
+
+        foreach (var id in _rw)
+        {
+            mask.writeAccess.SetBit(id);
+        }
+
+        // 4. Ask World for the Query (Cached)
+        var maskHash = mask.GetHashCode();
+        var queryID = world.ComponentManager.GetEntityQueryIDByMaskHash(maskHash);
+        if (queryID.IsValid)
+        {
+            // Check if the masks are actually equal (Hash collision?).
+            // Really worth it? It's unlikely to have collisions here.
+            if (world.ComponentManager.GetEntityQueryReference(queryID)._mask.Equals(mask))
+            {
+                mask.Dispose();
+                goto Return;
+            }
+        }
+
+        // NOTE: We do not dispose the mask here, as it is now owned by the EntityQuery.
+        queryID = world.ComponentManager.CreateEntityQuery(mask, maskHash);
+
+    Return:
+        Dispose();
+        return queryID;
+    }
+
+    private readonly void Dispose()
+    {
+        _scope.Dispose();
+    }
+}

src/Runtime/Ghost.Entities/SharedComponent.cs

@@ -0,0 +1,176 @@
+#if false
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+
+namespace Ghost.Entities;
+
+public interface ISharedComponent
+{
+}
+
+internal unsafe sealed class SharedComponentStore : IDisposable
+{
+    private struct EntryInfo
+    {
+        public int RefCount;
+        public int HashCode;
+        public int Version;
+        public int NextFree; // free-list linkage (index)
+    }
+
+    private struct TypeStore : IDisposable
+    {
+        public int TypeSize;
+        public UnsafeList<byte> Data;         // raw bytes, stride = TypeSize
+        public UnsafeList<EntryInfo> Infos;   // parallel to Data entries (Entry 0 reserved)
+        public UnsafeHashMap<long, int> HashLookup; // (hashKey) -> entryIndex
+        public int FreeListHead; // head index, 0 means none (we'll use Infos[0].NextFree too if you prefer)
+        public int VersionCounter;
+
+        public void Dispose()
+        {
+            Data.Dispose();
+            Infos.Dispose();
+            HashLookup.Dispose();
+        }
+    }
+
+    private readonly UnsafeHashMap<int, TypeStore> _perType; // componentTypeId -> TypeStore
+
+    public SharedComponentStore(int initialCapacity = 16)
+    {
+        _perType = new UnsafeHashMap<int, TypeStore>(initialCapacity, Allocator.Persistent);
+    }
+
+    public void Dispose()
+    {
+        foreach (var kvp in _perType)
+        {
+            kvp.Value.Dispose();
+        }
+
+        _perType.Dispose();
+    }
+
+    public int InsertOrGet(int componentTypeId, int typeSize, void* data, int hashCode)
+    {
+        // Reserve index 0 for "default"
+        if (data == null)
+        {
+            return 0;
+        }
+
+        ref var store = ref GetOrCreateTypeStore(componentTypeId, typeSize);
+
+        // Combine (typeId, hash) into a single key; collisions handled by memcmp below.
+        var key = ((long)componentTypeId << 32) ^ (uint)hashCode;
+
+        if (store.HashLookup.TryGetValue(key, out var existingIndex))
+        {
+            var existingPtr = (byte*)store.Data.GetUnsafePtr() + (existingIndex * store.TypeSize);
+            if (new Span<byte>(existingPtr, store.TypeSize).SequenceEqual(new Span<byte>(data, store.TypeSize)))
+            {
+                ((EntryInfo*)store.Infos.GetUnsafePtr())[existingIndex].RefCount++;
+                return existingIndex;
+            }
+            // If collision: fall through to insert (you may want a secondary structure).
+        }
+
+        int index = AllocateEntry(ref store);
+
+        var dst = (byte*)store.Data.GetUnsafePtr() + (index * store.TypeSize);
+        MemoryUtility.MemCpy(dst, data, (nuint)store.TypeSize);
+
+        store.Infos[index] = new EntryInfo
+        {
+            RefCount = 1,
+            HashCode = hashCode,
+            Version = ++store.VersionCounter,
+            NextFree = -1
+        };
+
+        store.HashLookup[key] = index;
+        return index;
+    }
+
+    public void AddRef(int componentTypeId, int index)
+    {
+        if (index == 0) return;
+        ref var store = ref _perType[componentTypeId];
+        store.Infos[index].RefCount++;
+    }
+
+    public void Release(int componentTypeId, int index)
+    {
+        if (index == 0) return;
+        ref var store = ref _perType.GetValueByKey(componentTypeId);
+
+        ref var info = ref store.Infos.Ptr[index];
+        info.RefCount--;
+        if (info.RefCount > 0) return;
+
+        // Remove from hash lookup (best-effort; collisions require more robust handling)
+        long key = ((long)componentTypeId << 32) ^ (uint)info.HashCode;
+        store.HashLookup.Remove(key);
+
+        // Push to free-list
+        info.NextFree = store.FreeListHead;
+        store.FreeListHead = index;
+    }
+
+    public void* GetDataPtr(int componentTypeId, int index)
+    {
+        if (index == 0) return null;
+        ref var store = ref _perType.GetValueByKey(componentTypeId);
+        return (byte*)store.Data.Ptr + (index * store.TypeSize);
+    }
+
+    private ref TypeStore GetOrCreateTypeStore(int componentTypeId, int typeSize)
+    {
+        if (_perType.TryGetValue(componentTypeId, out var existing))
+        {
+            // UnsafeHashMap returns by value in some implementations; you may need a different pattern here.
+            // Adjust to your container API (e.g., TryGetValueRef).
+        }
+
+        var store = new TypeStore
+        {
+            TypeSize = typeSize,
+            Data = new UnsafeList<byte>(typeSize * 16, Allocator.Persistent),
+            Infos = new UnsafeList<EntryInfo>(16, Allocator.Persistent),
+            HashLookup = new UnsafeHashMap<long, int>(16, Allocator.Persistent),
+            FreeListHead = 0,
+            VersionCounter = 0
+        };
+
+        // Create reserved default entry at index 0
+        store.Data.Resize(typeSize); // one element worth of bytes
+        store.Infos.Add(new EntryInfo { RefCount = int.MaxValue, HashCode = 0, Version = 0, NextFree = -1 });
+
+        _perType.Add(componentTypeId, store);
+        // NOTE: returning a ref requires a "get ref" API; adjust to your UnsafeHashMap capabilities.
+        return ref _perType.GetValueByKey(componentTypeId);
+    }
+
+    private static int AllocateEntry(ref TypeStore store)
+    {
+        if (store.FreeListHead != 0)
+        {
+            int idx = store.FreeListHead;
+            store.FreeListHead = store.Infos[idx].NextFree;
+            store.Infos[idx].NextFree = -1;
+            return idx;
+        }
+
+        int newIndex = store.Infos.Count;
+        store.Infos.Add(default);
+
+        int newByteCount = (newIndex + 1) * store.TypeSize;
+        store.Data.Resize(newByteCount);
+
+        return newIndex;
+    }
+}
+
+#endif

src/Runtime/Ghost.Entities/System.cs

@@ -0,0 +1,409 @@
+using Ghost.Core;
+
+namespace Ghost.Entities;
+
+public readonly ref struct SystemAPI
+{
+    public TimeData Time
+    {
+        get; init;
+    }
+}
+
+public interface ISystem
+{
+    World World
+    {
+        get; init;
+    }
+
+    void Initialize(ref readonly SystemAPI systemAPI);
+    void Update(ref readonly SystemAPI systemAPI);
+    void Cleanup(ref readonly SystemAPI systemAPI);
+}
+
+public abstract class SystemBase : ISystem
+{
+    private List<int>? _requiredQueries;
+
+    public World World
+    {
+        get; init;
+    } = null!;
+
+    public int LastSystemVersion
+    {
+        get; internal set;
+    } = -2;
+
+    private bool ShouldUpdate()
+    {
+        if (_requiredQueries == null || _requiredQueries.Count == 0)
+        {
+            return true;
+        }
+
+        foreach (var queryID in _requiredQueries)
+        {
+            ref var query = ref World.ComponentManager.GetEntityQueryReference(new Identifier<EntityQuery>(queryID));
+            if (query.GetEntityCount() == 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    protected void RequireQueryForUpdate(Identifier<EntityQuery> queryID)
+    {
+        _requiredQueries ??= new List<int>(4);
+        _requiredQueries.Add(queryID.Value);
+    }
+
+    void ISystem.Initialize(ref readonly SystemAPI systemAPI)
+    {
+        OnInitialize(in systemAPI);
+    }
+
+    void ISystem.Update(ref readonly SystemAPI systemAPI)
+    {
+        if (ShouldUpdate())
+        {
+            if (World.Version - LastSystemVersion > 1)
+            {
+                OnStartRunning();
+            }
+
+            OnUpdate(in systemAPI);
+            LastSystemVersion = World.Version;
+        }
+        else
+        {
+            if (World.Version - LastSystemVersion <= 1)
+            {
+                OnStopRunning();
+            }
+        }
+    }
+
+    void ISystem.Cleanup(ref readonly SystemAPI systemAPI)
+    {
+        OnCleanup(in systemAPI);
+    }
+
+    protected virtual void OnInitialize(ref readonly SystemAPI systemAPI)
+    {
+    }
+
+    protected virtual void OnUpdate(ref readonly SystemAPI systemAPI)
+    {
+    }
+
+    protected virtual void OnCleanup(ref readonly SystemAPI systemAPI)
+    {
+    }
+
+    protected virtual void OnStopRunning()
+    {
+    }
+
+    protected virtual void OnStartRunning()
+    {
+    }
+}
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
+public class UpdateAfterAttribute : Attribute
+{
+    public Type SystemType { get; }
+
+    public UpdateAfterAttribute(Type systemType)
+    {
+        SystemType = systemType;
+    }
+}
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
+public class UpdateBeforeAttribute : Attribute
+{
+    public Type SystemType { get; }
+
+    public UpdateBeforeAttribute(Type systemType)
+    {
+        SystemType = systemType;
+    }
+}
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
+public class SystemGroupAttribute : Attribute
+{
+    public Type GroupType { get; }
+
+    public SystemGroupAttribute(Type groupType)
+    {
+        GroupType = groupType;
+    }
+}
+
+#if false
+internal static partial class SystemGroupRegistry
+{
+    private static readonly Dictionary<Type, List<ISystem>> _systemGroupMap = new();
+
+    // TODO: Use Source Generators to generate group registrations at compile time.
+
+    public static void RegisterSystemGroup<T>(Type groupType)
+        where T : ISystem, new()
+    {
+        if (!_systemGroupMap.ContainsKey(typeof(T)))
+        {
+            _systemGroupMap[typeof(T)] = new();
+        }
+
+        _systemGroupMap[groupType].Add(new T());
+    }
+
+    public static List<ISystem> GetSystemsForGroup(Type groupType)
+    {
+        if (_systemGroupMap.TryGetValue(groupType, out var systems))
+        {
+            return systems;
+        }
+
+        throw new InvalidOperationException($"No systems registered for System Group of type {groupType.FullName}");
+    }
+}
+#endif
+
+public abstract class SystemGroup : ISystem
+{
+    private readonly List<ISystem> _systems = [];
+    private List<ISystem>? _sortedSystems;
+
+    private uint _version = 0;
+    private uint _sortedVersion = 0;
+
+    public World World
+    {
+        get; init;
+    } = null!;
+
+    // public SystemGroup()
+    // {
+    //     _systems = SystemGroupRegistry.GetSystemsForGroup(GetType());
+    // }
+
+    private static List<ISystem> Sort(List<ISystem> systems)
+    {
+        // 1. Build the Graph
+        // Key64: The System, Value: Systems that MUST run before the Key64
+        var dependencies = new Dictionary<Type, HashSet<Type>>();
+        var systemMap = systems.ToDictionary(s => s.GetType(), s => s);
+
+        foreach (var sys in systems)
+        {
+            var type = sys.GetType();
+            if (!dependencies.TryGetValue(type, out HashSet<Type>? value))
+            {
+                value = [];
+                dependencies[type] = value;
+            }
+
+            // Handle [UpdateAfter(typeof(Other))] -> Other comes before This
+            foreach (var attr in type.GetCustomAttributes(typeof(UpdateAfterAttribute), true))
+            {
+                var depType = ((UpdateAfterAttribute)attr).SystemType;
+                value.Add(depType);
+            }
+
+            // Handle [UpdateBefore(typeof(Other))] -> This comes before Other
+            // Which means: Other depends on This
+            foreach (var attr in type.GetCustomAttributes(typeof(UpdateBeforeAttribute), true))
+            {
+                var targetType = ((UpdateBeforeAttribute)attr).SystemType;
+                if (!dependencies.ContainsKey(targetType)) dependencies[targetType] = [];
+                dependencies[targetType].Add(type);
+            }
+        }
+
+        // 2. Topological Sort (Kahn's Algorithm variant)
+        var sortedList = new List<ISystem>();
+        var visited = new HashSet<Type>();
+
+        // We loop until we have sorted everyone
+        while (sortedList.Count < systems.Count)
+        {
+            bool addedAny = false;
+
+            foreach (var sys in systems)
+            {
+                var type = sys.GetType();
+                if (visited.Contains(type)) continue;
+
+                // Check if all dependencies for this system are already visited/sorted
+                bool canRun = true;
+                if (dependencies.TryGetValue(type, out var deps))
+                {
+                    foreach (var dep in deps)
+                    {
+                        // If the dependency exists in our list but hasn't run yet, we can't run.
+                        // (We check systemMap to ignore dependencies that don't exist in this world)
+                        if (systemMap.ContainsKey(dep) && !visited.Contains(dep))
+                        {
+                            canRun = false;
+                            break;
+                        }
+                    }
+                }
+
+                if (canRun)
+                {
+                    sortedList.Add(sys);
+                    visited.Add(type);
+                    addedAny = true;
+                }
+            }
+
+            if (!addedAny)
+            {
+                throw new InvalidOperationException("Circular Dependency detected in Systems! Check your [UpdateAfter] attributes.");
+            }
+        }
+
+        return sortedList;
+    }
+
+    public void AddSystem<T>()
+        where T : ISystem, new()
+    {
+        _systems.Add(new T()
+        {
+            World = World
+        });
+
+        _version++;
+    }
+
+    public void SortSystems()
+    {
+        if (_sortedVersion == _version)
+        {
+            return;
+        }
+
+        if (_systems.Count == 0)
+        {
+            _sortedSystems = [];
+            _sortedVersion = _version;
+            return;
+        }
+
+        _sortedSystems = Sort(_systems);
+        _sortedVersion = _version;
+    }
+
+    private void ThrowIfNotSorted()
+    {
+        if (_sortedSystems == null || _sortedVersion != _version)
+        {
+            throw new InvalidOperationException("Systems must be sorted before calling this method. Call SortSystems() after adding all systems.");
+        }
+    }
+
+    public void Initialize(ref readonly SystemAPI systemAPI)
+    {
+        ThrowIfNotSorted();
+
+        foreach (var system in _sortedSystems!)
+        {
+            system.Initialize(in systemAPI);
+        }
+    }
+
+    public void Update(ref readonly SystemAPI systemAPI)
+    {
+        ThrowIfNotSorted();
+
+        foreach (var system in _sortedSystems!)
+        {
+            system.Update(in systemAPI);
+        }
+    }
+
+    public void Cleanup(ref readonly SystemAPI systemAPI)
+    {
+        ThrowIfNotSorted();
+
+        foreach (var system in _sortedSystems!)
+        {
+            system.Cleanup(in systemAPI);
+        }
+    }
+}
+
+public class DefaultSystemGroup : SystemGroup
+{
+}
+
+public class SystemManager
+{
+    private readonly World _world;
+
+    private readonly List<ISystem> _systems = [];
+
+    internal IReadOnlyList<ISystem> Systems => _systems;
+
+    internal SystemManager(World world)
+    {
+        _world = world;
+        AddSystem<DefaultSystemGroup>();
+    }
+
+    public void AddSystem<T>()
+        where T : ISystem, new()
+    {
+        _systems.Add(new T()
+        {
+            World = _world
+        });
+    }
+
+    public T GetSystem<T>()
+        where T : ISystem
+    {
+        foreach (var system in _systems)
+        {
+            if (system is T typedSystem)
+            {
+                return typedSystem;
+            }
+        }
+
+        throw new InvalidOperationException($"System of type {typeof(T).FullName} not found in SystemManager.");
+    }
+
+    internal void InitializeAll(ref readonly SystemAPI systemAPI)
+    {
+        foreach (var system in _systems)
+        {
+            system.Initialize(in systemAPI);
+        }
+    }
+
+    internal void UpdateAll(ref readonly SystemAPI systemAPI)
+    {
+        foreach (var system in _systems)
+        {
+            system.Update(in systemAPI);
+        }
+    }
+
+    internal void CleanupAll(ref readonly SystemAPI systemAPI)
+    {
+        foreach (var system in _systems)
+        {
+            system.Cleanup(in systemAPI);
+        }
+    }
+}

src/Runtime/Ghost.Entities/Templates/EntityQuery.ComponentIterator.tt

@@ -0,0 +1,234 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public unsafe partial struct EntityQuery
+{
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendParameters(i, "T{0}");
+    var compGenerics = AppendParameters(i, "ref T{0} component{0}");
+    var deconstrictOutPrams = AppendParameters(i, "out Ref<T{0}> component{0}");
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 2);
+#>
+    public readonly ref struct ComponentIterator<<#= generics#>>
+<#= restrictions #>
+    {
+<# if (i > 1) { #>
+        public ref struct QueryItem
+        {
+<# for (var j = 0; j < i; j++) { #>
+            public ref T<#= j #> component<#= j #>;
+<# } #>
+            internal QueryItem(<#= compGenerics #>)
+            {
+<# for (var j = 0; j < i; j++) { #>
+                this.component<#= j #> = ref component<#= j #>;
+<# } #>
+            }
+
+            public void Deconstruct(<#= deconstrictOutPrams #>)
+            {
+<# for (var j = 0; j < i; j++) { #>
+                component<#= j #> = new Ref<T<#= j #>>(ref this.component<#= j #>);
+<# } #>
+            }
+        }
+
+<# } #>
+        public ref struct Enumerator : IDisposable
+        {
+            private fixed int _compTypeIDs[<#= i #>];
+            private fixed int _offsets[<#= i #>];
+            private fixed long _compBasePtrs[<#= i #>];
+
+            private readonly ReadOnlyUnsafeCollection<Identifier<Archetype>> _matchingArchetypes;
+            private readonly EntityQueryMask _mask;
+            private readonly World _world;
+
+            private readonly Stack.Scope _scope;
+            private UnsafeList<int> _changedComponentIDs;
+
+            private ref Archetype _currentArchetype;
+            private ref Chunk _currentChunk;
+            private byte* _chunkBasePtr;
+
+            private int _currentChunkEntityCount;
+            private int _currentArchetypeIndex;
+            private int _currentChunkIndex;
+            private int _currentEntityIndex;
+
+            internal Enumerator(ReadOnlyUnsafeCollection<Identifier<Archetype>> matchingArchetypes, EntityQueryMask mask, World world)
+            {
+<# for (var j = 0; j < i; j++) { #>
+                _compTypeIDs[<#= j #>] = ComponentTypeID<T<#= j #>>.Value;
+                _offsets[<#= j #>] = 0;
+                _compBasePtrs[<#= j #>] = 0;
+
+<# } #>
+                _matchingArchetypes = matchingArchetypes;
+                _mask = mask;
+                _world = world;
+
+                _scope = AllocationManager.CreateStackScope();
+                _changedComponentIDs = new UnsafeList<int>(<#= i #>, _scope.AllocationHandle);
+
+                var it = _mask.writeAccess.GetIterator();
+                while (it.Next(out var id))
+                {
+                    for (var i = 0; i < <#= i #>; i++)
+                    {
+                        if (id == _compTypeIDs[i])
+                        {
+                            _changedComponentIDs.Add(id);
+                            break;
+                        }
+                    }
+                }
+
+                Reset();
+            }
+
+<# if (i > 1) { #>
+            public QueryItem Current => new(
+<# for (var j = 0; j < i; j++) { #>
+                ref *(T<#= j #>*)(_compBasePtrs[<#= j #>] + _currentEntityIndex * sizeof(T<#= j #>))<#= j < i - 1 ? "," : "" #>
+<# } #>
+            );
+<# } else { #>
+            public ref T0 Current => ref *(T0*)(_compBasePtrs[0] + _currentEntityIndex * sizeof(T0));
+<# } #>
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            private void SetChunk(int chunkIndex)
+            {
+                _currentChunk = ref _currentArchetype.GetChunkReference(chunkIndex);
+                _chunkBasePtr = _currentChunk.GetUnsafePtr();
+                _currentChunkEntityCount = _currentChunk._count;
+
+                for (var index = 0; index < <#= i #>; index++)
+                {
+                    var layout = _currentArchetype.GetLayout(_compTypeIDs[index])
+                        .GetValueOrThrow();
+                    _offsets[index] = layout.offset;
+                    _compBasePtrs[index] = (long)(_chunkBasePtr + _offsets[index]);
+                }
+
+                for (var i = 0; i < _changedComponentIDs.Count; i++)
+                {
+                    _currentArchetype.MarkChanged(_currentChunkIndex, _changedComponentIDs[i], _world.Version);
+                }
+            }
+
+            public bool MoveNext()
+            {
+                while (true)
+                {
+                    _currentEntityIndex++;
+                    if (_currentEntityIndex < _currentChunk._count)
+                    {
+                        var pChunkData = _currentChunk.GetUnsafePtr();
+                        if (IsEntityValid(pChunkData, _currentEntityIndex, in _currentArchetype, in _mask))
+                        {
+                            return true;
+                        }
+
+                        continue;
+                    }
+
+                    _currentChunkIndex++;
+                    if (!Unsafe.IsNullRef(ref _currentArchetype) && _currentChunkIndex < _currentArchetype.ChunkCount)
+                    {
+                        SetChunk(_currentChunkIndex);
+                        _currentEntityIndex = -1; // Reset for new chunk
+
+                        continue;
+                    }
+
+                    _currentArchetypeIndex++;
+                    if (_currentArchetypeIndex < _matchingArchetypes.Count)
+                    {
+                        _currentArchetype = ref _world.ComponentManager.GetArchetypeReference(_matchingArchetypes[_currentArchetypeIndex]);
+
+                        _currentChunkIndex = 0;
+                        if (_currentArchetype.ChunkCount > 0)
+                        {
+                            SetChunk(0);
+                            _currentEntityIndex = -1;
+                            continue;
+                        }
+
+                        // If archetype has no chunks, loop will try next archetype
+                    }
+                    else
+                    {
+                        return false; // End of all data
+                    }
+                }
+            }
+
+            public void Reset()
+            {
+                _currentArchetype = ref Unsafe.NullRef<Archetype>();
+                _currentChunk = ref Unsafe.NullRef<Chunk>();
+                _currentArchetypeIndex = 0;
+                _currentChunkIndex = 0;
+                _currentEntityIndex = -1;
+
+                if (_matchingArchetypes.Count > 0)
+                {
+                    _currentArchetype = ref _world.ComponentManager.GetArchetypeReference(_matchingArchetypes[0]);
+                    if (_currentArchetype.ChunkCount > 0)
+                    {
+                        SetChunk(0);
+                    }
+                }
+            }
+
+            public readonly void Dispose()
+            {
+                _scope.Dispose();
+            }
+        }
+
+        private readonly ReadOnlyUnsafeCollection<Identifier<Archetype>> _matchingArchetypes;
+        private readonly EntityQueryMask _mask;
+        private readonly World _world;
+
+        internal ComponentIterator(ReadOnlyUnsafeCollection<Identifier<Archetype>> matchingArchetypes, EntityQueryMask mask, World world)
+        {
+            _matchingArchetypes = matchingArchetypes;
+            _mask = mask;
+            _world = world;
+        }
+
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(_matchingArchetypes, _mask, _world);
+        }
+    }
+
+    public readonly ComponentIterator<<#= generics#>> GetComponentIterator<<#= generics#>>()
+<#= restrictions #>
+    {
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return default;
+        }
+
+        return new ComponentIterator<<#= generics#>>(_matchingArchetypes.AsReadOnly(), _mask, world);
+    }
+
+<# } #>
+}

src/Runtime/Ghost.Entities/Templates/EntityQuery.EntityComponentIterator.tt

@@ -0,0 +1,235 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+using Ghost.Core;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public unsafe partial struct EntityQuery
+{
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendParameters(i, "T{0}");
+    var compGenerics = AppendParameters(i, "ref T{0} component{0}");
+    var deconstrictOutPrams = AppendParameters(i, "out Ref<T{0}> component{0}");
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 2);
+#>
+    public readonly ref struct EntityComponentIterator<<#= generics #>>
+<#= restrictions #>
+    {
+        public ref struct QueryItem
+        {
+            public Entity entity;
+
+<# for (var j = 0; j < i; j++) { #>
+            public ref T<#= j #> component<#= j #>;
+<# } #>
+            internal QueryItem(Entity entity, <#= compGenerics #>)
+            {
+                this.entity = entity;
+
+<# for (var j = 0; j < i; j++) { #>
+                this.component<#= j #> = ref component<#= j #>;
+<# } #>
+            }
+
+            public void Deconstruct(out Entity entity, <#= deconstrictOutPrams #>)
+            {
+                entity = this.entity;
+
+<# for (var j = 0; j < i; j++) { #>
+                component<#= j #> = new Ref<T<#= j #>>(ref this.component<#= j #>);
+<# } #>
+            }
+        }
+
+        public ref struct Enumerator : IDisposable
+        {
+            private fixed int _compTypeIDs[<#= i #>];
+            private fixed int _offsets[<#= i #>];
+            private fixed long _compBasePtrs[<#= i #>];
+
+            private readonly ReadOnlyUnsafeCollection<Identifier<Archetype>> _matchingArchetypes;
+            private readonly EntityQueryMask _mask;
+            private readonly World _world;
+
+            private readonly Stack.Scope _scope;
+            private UnsafeList<int> _changedComponentIDs;
+
+            private ref Archetype _currentArchetype;
+            private ref Chunk _currentChunk;
+            private byte* _chunkBasePtr;
+
+            private int _currentChunkEntityCount;
+            private int _currentArchetypeIndex;
+            private int _currentChunkIndex;
+            private int _currentEntityIndex;
+
+            internal Enumerator(ReadOnlyUnsafeCollection<Identifier<Archetype>> matchingArchetypes, EntityQueryMask mask, World world)
+            {
+<# for (var j = 0; j < i; j++) { #>
+                _compTypeIDs[<#= j #>] = ComponentTypeID<T<#= j #>>.Value;
+                _offsets[<#= j #>] = 0;
+                _compBasePtrs[<#= j #>] = 0;
+
+<# } #>
+                _matchingArchetypes = matchingArchetypes;
+                _mask = mask;
+                _world = world;
+
+                _scope = AllocationManager.CreateStackScope();
+                _changedComponentIDs = new UnsafeList<int>(<#= i #>, _scope.AllocationHandle);
+
+                var it = _mask.writeAccess.GetIterator();
+                while (it.Next(out var id))
+                {
+                    for (var i = 0; i < <#= i #>; i++)
+                    {
+                        if (id == _compTypeIDs[i])
+                        {
+                            _changedComponentIDs.Add(id);
+                            break;
+                        }
+                    }
+                }
+
+                Reset();
+            }
+
+            public QueryItem Current => new(
+                *(Entity*)(_chunkBasePtr + _currentArchetype.EntityIDsOffset + _currentEntityIndex * sizeof(Entity)),
+<# for (var j = 0; j < i; j++) { #>
+                ref *(T<#= j #>*)(_compBasePtrs[<#= j #>] + _currentEntityIndex * sizeof(T<#= j #>))<#= j < i - 1 ? "," : "" #>
+<# } #>
+            );
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            private void SetChunk(int chunkIndex)
+            {
+                _currentChunk = ref _currentArchetype.GetChunkReference(chunkIndex);
+                _chunkBasePtr = _currentChunk.GetUnsafePtr();
+                _currentChunkEntityCount = _currentChunk._count;
+
+                for (var index = 0; index < <#= i #>; index++)
+                {
+                    var layout = _currentArchetype.GetLayout(_compTypeIDs[index])
+                        .GetValueOrThrow();
+                    _offsets[index] = layout.offset;
+                    _compBasePtrs[index] = (long)(_chunkBasePtr + _offsets[index]);
+                }
+
+                for (var i = 0; i < _changedComponentIDs.Count; i++)
+                {
+                    _currentArchetype.MarkChanged(_currentChunkIndex, _changedComponentIDs[i], _world.Version);
+                }
+            }
+
+            public bool MoveNext()
+            {
+                while (true)
+                {
+                    _currentEntityIndex++;
+                    if (_currentEntityIndex < _currentChunk._count)
+                    {
+                        var pChunkData = _currentChunk.GetUnsafePtr();
+                        if (IsEntityValid(pChunkData, _currentEntityIndex, in _currentArchetype, in _mask))
+                        {
+                            return true;
+                        }
+
+                        continue;
+                    }
+
+                    _currentChunkIndex++;
+                    if (!Unsafe.IsNullRef(ref _currentArchetype) && _currentChunkIndex < _currentArchetype.ChunkCount)
+                    {
+                        SetChunk(_currentChunkIndex);
+                        _currentEntityIndex = -1; // Reset for new chunk
+
+                        continue;
+                    }
+
+                    _currentArchetypeIndex++;
+                    if (_currentArchetypeIndex < _matchingArchetypes.Count)
+                    {
+                        _currentArchetype = ref _world.ComponentManager.GetArchetypeReference(_matchingArchetypes[_currentArchetypeIndex]);
+
+                        _currentChunkIndex = 0;
+                        if (_currentArchetype.ChunkCount > 0)
+                        {
+                            SetChunk(0);
+                            _currentEntityIndex = -1;
+                            continue;
+                        }
+
+                        // If archetype has no chunks, loop will try next archetype
+                    }
+                    else
+                    {
+                        return false; // End of all data
+                    }
+                }
+            }
+
+            public void Reset()
+            {
+                _currentArchetype = ref Unsafe.NullRef<Archetype>();
+                _currentChunk = ref Unsafe.NullRef<Chunk>();
+                _currentArchetypeIndex = 0;
+                _currentChunkIndex = 0;
+                _currentEntityIndex = -1;
+
+                if (_matchingArchetypes.Count > 0)
+                {
+                    _currentArchetype = ref _world.ComponentManager.GetArchetypeReference(_matchingArchetypes[0]);
+                    if (_currentArchetype.ChunkCount > 0)
+                    {
+                        SetChunk(0);
+                    }
+                }
+            }
+
+            public readonly void Dispose()
+            {
+                _scope.Dispose();
+            }
+        }
+
+        private readonly ReadOnlyUnsafeCollection<Identifier<Archetype>> _matchingArchetypes;
+        private readonly EntityQueryMask _mask;
+        private readonly World _world;
+
+        internal EntityComponentIterator(ReadOnlyUnsafeCollection<Identifier<Archetype>> matchingArchetypes, EntityQueryMask mask, World world)
+        {
+            _matchingArchetypes = matchingArchetypes;
+            _mask = mask;
+            _world = world;
+        }
+
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(_matchingArchetypes, _mask, _world);
+        }
+    }
+
+    public readonly EntityComponentIterator<<#= generics#>> GetEntityComponentIterator<<#= generics#>>()
+<#= restrictions #>
+    {
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return default;
+        }
+
+        return new EntityComponentIterator<<#= generics#>>(_matchingArchetypes.AsReadOnly(), _mask, world);
+    }
+
+<# } #>
+}

src/Runtime/Ghost.Entities/Templates/EntityQuery.ForEach.tt

@@ -0,0 +1,119 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+namespace Ghost.Entities;
+
+public unsafe partial struct EntityQuery
+{
+<# for (var f = 0; f < 2; f++)
+{
+    var isForEachWithEntity = f != 0;
+#>
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendParameters(i, "T{0}");
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 2);
+
+    var delegateTupe = isForEachWithEntity ? "ForEachWithEntity" : "ForEach";
+#>
+    public readonly void ForEach<<#= generics #>>(<#= delegateTupe #><<#= generics #>> action)
+<#= restrictions #>
+    {
+        var world = World.GetWorldUncheck(_worldID);
+        var globalVersion = world.Version;
+
+<# for (var localIndex = 0; localIndex < i; localIndex++) { #>
+        var comp<#= localIndex #>TypeID = ComponentTypeID<T<#= localIndex #>>.Value;
+<# } #>
+
+        var compTypeIDs = stackalloc int[]
+        {
+<# for (var localIndex = 0; localIndex < i; localIndex++) { #>
+            comp<#= localIndex #>TypeID.Value,
+<# } #>
+        };
+
+        var changedCompIDs = stackalloc int[<#= i #>];
+        var offsets = stackalloc int[<#= i #>];
+        var basePtrs = stackalloc byte*[<#= i #>];
+
+        var changedCompCount = 0;
+
+        var it = _mask.writeAccess.GetIterator();
+        while (it.Next(out var id))
+        {
+            for (var i =0; i < <#= i #>; i++)
+            {
+                if (id == compTypeIDs[i])
+                {
+                    changedCompIDs[changedCompCount] = id;
+                    changedCompCount++;
+                    break;
+                }
+            }
+        }
+
+        for (var i = 0; i < _matchingArchetypes.Count; i++)
+        {
+            ref var archetype = ref world.ComponentManager.GetArchetypeReference(_matchingArchetypes[i]);
+            var hasAllComponents = true;
+            for (var index = 0; index < <#= i #>; index++)
+            {
+                var layoutResult = archetype.GetLayout(compTypeIDs[index]);
+                if (!layoutResult)
+                {
+                    hasAllComponents = false;
+                    break;
+                }
+
+                offsets[index] = layoutResult.Value.offset;
+            }
+
+            if (!hasAllComponents)
+            {
+                continue;
+            }
+
+            for (var chunkIndex = 0; chunkIndex < archetype.ChunkCount; chunkIndex++)
+            {
+                ref var chunk = ref archetype.GetChunkReference(chunkIndex);
+                var pChunkData = chunk.GetUnsafePtr();
+
+                for (var j = 0; j < changedCompCount; j++)
+                {
+                    archetype.MarkChanged(chunkIndex, changedCompIDs[j], globalVersion);
+                }
+
+                for (var index = 0; index < <#= i #>; index++)
+                {
+                    basePtrs[index] = pChunkData + offsets[index];
+                }
+
+                for (var entityIndex = 0; entityIndex < chunk._count; entityIndex++)
+                {
+                    if (!IsEntityValid(pChunkData, entityIndex, in archetype, in _mask))
+                    {
+                        continue;
+                    }
+
+<# for (var localIndex = 0; localIndex < i; localIndex++) { #>
+                    var pComp<#= localIndex #> = (T<#= localIndex #>*)(basePtrs[<#= localIndex #>] + (sizeof(T<#= localIndex #>) * entityIndex));
+<# } #>
+
+<# if (isForEachWithEntity) { #>
+                    var pEntity = (Entity*)(pChunkData + archetype.EntityIDsOffset + (sizeof(Entity) * entityIndex));
+                    action(*pEntity, <#= AppendParameters(i, "ref *pComp{0}") #>);
+<# } else { #>
+                    action(<#= AppendParameters(i, "ref *pComp{0}") #>);
+<# } #>
+                }
+            }
+        }
+    }
+
+<# } #>
+<# } #>
+}

src/Runtime/Ghost.Entities/Templates/EntityQuery.JobEntity.tt

@@ -0,0 +1,243 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+using Ghost.Core;
+using Misaki.HighPerformance.Jobs;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Ghost.Entities;
+
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendGenerics(i);
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 1);
+#>
+public interface IJobEntity<<#= generics #>>
+<#= restrictions #>
+{
+    void Execute(Entity entity, <#= AppendParameters(i, "ref T{0} component{0}") #>, int threadIndex);
+}
+
+internal unsafe struct JobEntityBatch<TJob, <#= generics #>> : IJobParallelFor
+    where TJob : unmanaged, IJobEntity<<#= generics #>>
+<#= restrictions #>
+{
+    public fixed int componentIDs[<#= i #>];
+    public fixed bool componentRW[<#= i #>];
+
+    public TJob userJob;
+
+    public UnsafeList<IntPtr> chunks;
+    public UnsafeList<IntPtr> chunkVersions;
+    public UnsafeList<int> chunkCount;
+    public UnsafeList<int> entityOffset;
+
+<# for (var j = 0; j < i; j++){ #>
+    public UnsafeList<int> offsets<#= j #>;
+    public UnsafeList<int> bitsOffsets<#= j #>;
+    public UnsafeList<int> versionindices<#= j #>;
+
+<# } #>
+    public int version;
+
+    public void Execute(int loopIndex, int threadIndex)
+    {
+        // 1. Get the specific pChunk for this thread
+        var pChunk = (byte*)chunks[loopIndex];
+        var pVersions = (int*)chunkVersions[loopIndex];
+        var count = chunkCount[loopIndex];
+
+<# for (var j = 0; j < i; j++){ #>
+        var off<#= j #> = offsets<#= j #>[loopIndex];
+        var enableOff<#= j #> = bitsOffsets<#= j #>[loopIndex];
+        var versionIndex<#= j #> = versionindices<#= j #>[loopIndex];
+
+<# } #>
+        var pEntity = (Entity*)(pChunk + entityOffset[loopIndex]);
+<# for (var j = 0; j < i; j++){ #>
+        var ptr<#= j #> = (<#= "T" + j #>*)(pChunk + off<#= j #>);
+<# } #>
+
+        // 2. Update versions for RW components
+<# for (var j = 0; j < i; j++){ #>
+        if (componentRW[<#= j #>])
+        {
+            pVersions[versionIndex<#= j #>] = version;
+        }
+
+<# } #>
+        // 3. Iterate all entities in this chunk
+        for (var i = 0; i < count; i++)
+        {
+<# for (var j = 0; j < i; j++){ #>
+            if (enableOff<#= j #> != -1 && !EntityQuery.CheckBit(pChunk + enableOff<#= j #>, i))
+            {
+                continue;
+            }
+
+<# } #>
+            userJob.Execute(pEntity[i], <#= AppendParameters(i, "ref ptr{0}[i]") #>, threadIndex);
+        }
+    }
+}
+
+<# } #>
+public unsafe partial struct EntityQuery
+{
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendGenerics(i);
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 2);
+#>
+    private struct DisposeJobEntity<#= i #> : IJob
+    {
+        public UnsafeList<IntPtr> chunks;
+        public UnsafeList<IntPtr> chunkVersions;
+        public UnsafeList<int> chunkEntityCounts;
+        public UnsafeList<int> entityOffsets;
+
+<# for (var j = 0; j < i; j++){ #>
+        public UnsafeList<int> offsets<#= j #>;
+        public UnsafeList<int> bitsOffsets<#= j #>;
+        public UnsafeList<int> versionindices<#= j #>;
+
+<# } #>
+        public void Execute(int threadIndex)
+        {
+            chunks.Dispose();
+            chunkVersions.Dispose();
+            chunkEntityCounts.Dispose();
+            entityOffsets.Dispose();
+
+<# for (var j = 0; j < i; j++){ #>
+            offsets<#= j #>.Dispose();
+            bitsOffsets<#= j #>.Dispose();
+            versionindices<#= j #>.Dispose();
+
+<# } #>
+        }
+    }
+
+    public JobHandle ScheduleEntityParallel<TJob, <#= generics #>>(TJob jobData, int batchSize, JobHandle dependency)
+        where TJob : unmanaged, IJobEntity<<#= generics #>>
+<#= restrictions #>
+    {
+        var world = World.GetWorld(_worldID);
+        if (world is null)
+        {
+            return JobHandle.Invalid;
+        }
+
+        if (world.JobScheduler == null)
+        {
+            throw new InvalidOperationException("The World has no JobScheduler assigned.");
+        }
+
+        // 1. Flatten the World
+        var chunks = new UnsafeList<IntPtr>(128, JobScheduler.TempAllocatorHandle);
+        var chunkVersions = new UnsafeList<IntPtr>(128, JobScheduler.TempAllocatorHandle);
+        var chunkEntityCounts = new UnsafeList<int>(128, JobScheduler.TempAllocatorHandle);
+        var entityOffsets = new UnsafeList<int>(128, JobScheduler.TempAllocatorHandle);
+
+<# for (var j = 0; j < i; j++){ #>
+        var offsets<#= j #> = new UnsafeList<int>(128, JobScheduler.TempAllocatorHandle);
+        var bitsOffsets<#= j #> = new UnsafeList<int>(128, JobScheduler.TempAllocatorHandle);
+        var versionIndices<#= j #> = new UnsafeList<int>(128, JobScheduler.TempAllocatorHandle);
+
+<# } #>
+        // Iterate the Query's matching archetypes
+        foreach (var archID in _matchingArchetypes)
+        {
+            ref var arch = ref world.ComponentManager.GetArchetypeReference(archID);
+
+            if (arch.ChunkCount == 0)
+            {
+                continue;
+            }
+
+            // Get offsets ONCE per archetype
+<# for (var j = 0; j < i; j++){ #>
+            var layout<#= j #> = arch.GetLayout(ComponentTypeID<T<#= j #>>.Value)
+                .GetValueOrThrow();
+<# } #>
+
+            // Add all chunks from this archetype
+            for (var i = 0; i < arch.ChunkCount; i++)
+            {
+                ref var chunkRef = ref arch.GetChunkReference(i);
+
+                chunks.Add((IntPtr)chunkRef.GetUnsafePtr());
+                chunkVersions.Add((IntPtr)chunkRef.GetVersionUnsafePtr());
+                chunkEntityCounts.Add(chunkRef._count);
+                entityOffsets.Add(arch.EntityIDsOffset);
+
+<# for (var j = 0; j < i; j++){ #>
+                offsets<#= j #>.Add(layout<#= j #>.offset);
+                bitsOffsets<#= j #>.Add(layout<#= j #>.enableBitsOffset);
+                versionIndices<#= j #>.Add(layout<#= j #>.versionIndex);
+
+<# } #>
+            }
+        }
+
+        // 2. Create the Runner
+        var runner = new JobEntityBatch<TJob, <#= generics #>>
+        {
+            userJob = jobData,
+            chunks = chunks,
+            chunkVersions = chunkVersions,
+            chunkCount = chunkEntityCounts,
+            entityOffset = entityOffsets,
+
+<# for (var j = 0; j < i; j++){ #>
+            offsets<#= j #> = offsets<#= j #>,
+            bitsOffsets<#= j #> = bitsOffsets<#= j #>,
+            versionindices<#= j #> = versionIndices<#= j #>,
+
+<# } #>
+            version = world.Version,
+        };
+
+        runner.componentIDs[0] = ComponentTypeID<T0>.Value;
+
+        var it = _mask.writeAccess.GetIterator();
+        while (it.Next(out var id))
+        {
+            for (var i =0; i < 1; i++)
+            {
+                if (id == runner.componentIDs[i])
+                {
+                    runner.componentRW[i] = true;
+                    break;
+                }
+            }
+        }
+
+        var jobHandle = world.JobScheduler.ScheduleParallel(ref runner, chunks.Count, batchSize, dependency);
+
+        // 3. Dispose the temp lists
+        var disposeJob = new DisposeJobEntity<#= i #>
+        {
+            chunks = chunks,
+            chunkVersions = chunkVersions,
+            chunkEntityCounts = chunkEntityCounts,
+            entityOffsets = entityOffsets,
+
+<# for (var j = 0; j < i; j++){ #>
+            offsets<#= j #> = offsets<#= j #>,
+            bitsOffsets<#= j #> = bitsOffsets<#= j #>,
+            versionindices<#= j #> = versionIndices<#= j #>,
+
+<# } #>
+        };
+
+        world.JobScheduler.Schedule(ref disposeJob, jobHandle);
+
+        return jobHandle;
+    }
+
+<# } #>
+}

src/Runtime/Ghost.Entities/Templates/ForEach.gen.cs

@@ -0,0 +1,36 @@
+
+namespace Ghost.Entities;
+
+public delegate void ForEach<T0>(ref T0 component0)
+    where T0 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1>(ref T0 component0, ref T1 component1)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2>(ref T0 component0, ref T1 component1, ref T2 component2)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2, T3>(ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2, T3, T4>(ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2, T3, T4, T5>(ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2, T3, T4, T5, T6>(ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component6)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent where T6 : unmanaged, IComponent;
+public delegate void ForEach<T0, T1, T2, T3, T4, T5, T6, T7>(ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component6, ref T7 component7)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent where T6 : unmanaged, IComponent where T7 : unmanaged, IComponent;
+
+public delegate void ForEachWithEntity<T0>(Entity entity, ref T0 component0)
+    where T0 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1>(Entity entity, ref T0 component0, ref T1 component1)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2, T3>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2, T3, T4>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2, T3, T4, T5>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2, T3, T4, T5, T6>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component6)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent where T6 : unmanaged, IComponent;
+public delegate void ForEachWithEntity<T0, T1, T2, T3, T4, T5, T6, T7>(Entity entity, ref T0 component0, ref T1 component1, ref T2 component2, ref T3 component3, ref T4 component4, ref T5 component5, ref T6 component6, ref T7 component7)
+    where T0 : unmanaged, IComponent where T1 : unmanaged, IComponent where T2 : unmanaged, IComponent where T3 : unmanaged, IComponent where T4 : unmanaged, IComponent where T5 : unmanaged, IComponent where T6 : unmanaged, IComponent where T7 : unmanaged, IComponent;

src/Runtime/Ghost.Entities/Templates/ForEach.tt

@@ -0,0 +1,27 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+namespace Ghost.Entities;
+
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendParameters(i, "T{0}");
+    var compGenerics = AppendParameters(i, "ref T{0} component{0}");
+    var restrictions = AppendGenericRestrictions(i, "unmanaged, IComponent");
+#>
+public delegate void ForEach<<#= generics #>>(<#= compGenerics #>)
+    <#= restrictions #>;
+<# } #>
+
+<# for (var i = 1; i <= Amount; i++)
+{
+    var generics = AppendParameters(i, "T{0}");
+    var compGenerics = AppendParameters(i, "ref T{0} component{0}");
+    var restrictions = AppendGenericRestrictions(i, "unmanaged, IComponent");
+#>
+public delegate void ForEachWithEntity<<#= generics #>>(Entity entity, <#= compGenerics #>)
+    <#= restrictions #>;
+<# } #>

src/Runtime/Ghost.Entities/Templates/Helpers.ttinclude

@@ -0,0 +1,147 @@
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#+
+
+    public int Amount = 8;
+    public int ExtensionAmount = 3;
+
+    public string Indent(StringBuilder sb, int spaces)
+    {
+        var indent = new string(' ', spaces);
+        return sb.ToString().Replace("\n", "\n" + indent);
+    }
+
+    string AppendGenerics(int amount, string template)
+    {
+        var sb = new StringBuilder();
+        for (var i = 0; i < amount; i++)
+        {
+            if (i > 0) sb.Append(", ");
+            sb.Append(string.Format(template, i));
+        }
+
+        return sb.ToString();
+    }
+
+    string AppendGenerics(int amount)
+    {
+        return AppendGenerics(amount, "T{0}");
+    }
+
+    public StringBuilder AppendParameters(int amount, string template)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append(string.Format(template, localIndex));
+            if (localIndex < amount - 1)
+            {
+                sb.Append(", ");
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder AppendGenericRestrictions(int amount, string Ttemplate, string template)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"where {Ttemplate}{localIndex} : {template}");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(' ');
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder AppendGenericRestrictions(int amount, string template)
+    {
+        return AppendGenericRestrictions(amount, "T", template);
+    }
+
+    public StringBuilder AppendGenericRestrictionsMultiline(int amount, string Ttemplate, string template, int indentation)
+    {
+        var sb = new StringBuilder();
+        var spaces = new string(' ', indentation * 4);
+
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"{spaces}where {Ttemplate}{localIndex} : {template}");
+            if (localIndex < amount - 1)
+            {
+                sb.AppendLine();
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder AppendGenericRestrictionsMultiline(int amount, string template, int indentation)
+    {
+        return AppendGenericRestrictionsMultiline(amount, "T", template, indentation);
+    }
+
+    public StringBuilder TryGetComponentPools(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"_componentStorage.TryGetPool<T{localIndex}>(out var pool{localIndex})");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(" && ");
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder HasEntity(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 1; localIndex < amount; localIndex++)
+        {
+            sb.Append($"pool{localIndex}.Has(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(" && ");
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder GetComponent(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"pool{localIndex}.GetRef(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(", ");
+            }
+        }
+
+        return sb;
+    }
+
+    public StringBuilder GetComponentRef(int amount)
+    {
+        var sb = new StringBuilder();
+        for (var localIndex = 0; localIndex < amount; localIndex++)
+        {
+            sb.Append($"ref pool{localIndex}.GetRef(entity)");
+            if (localIndex < amount - 1)
+            {
+                sb.Append(", ");
+            }
+        }
+
+        return sb;
+    }
+#>

src/Runtime/Ghost.Entities/Templates/QueryBuilder.With.gen.cs

@@ -0,0 +1,380 @@
+
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public ref partial struct QueryBuilder
+{
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAll<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAllRW<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Any' filter of the query.
+    /// Targets entities that have at least one of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAny<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _any.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Absent' filter of the query.
+    /// Targets entities that do not have any of the specified component types.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAbsent<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _absent.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'None' filter of the query.
+    /// Targets entities that do not have any of the specified component types, or those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithNone<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _none.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Disabled' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithDisabled<T0>()
+        where T0 : unmanaged, IEnableableComponent
+    {
+        _disabled.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresent<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresentRW<T0>()
+        where T0 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAll<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+        _all.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAllRW<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+        _all.Add(ComponentTypeID<T1>.Value);
+        _rw.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Any' filter of the query.
+    /// Targets entities that have at least one of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAny<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _any.Add(ComponentTypeID<T0>.Value);
+        _any.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Absent' filter of the query.
+    /// Targets entities that do not have any of the specified component types.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAbsent<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _absent.Add(ComponentTypeID<T0>.Value);
+        _absent.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'None' filter of the query.
+    /// Targets entities that do not have any of the specified component types, or those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithNone<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _none.Add(ComponentTypeID<T0>.Value);
+        _none.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Disabled' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithDisabled<T0, T1>()
+        where T0 : unmanaged, IEnableableComponent
+        where T1 : unmanaged, IEnableableComponent
+    {
+        _disabled.Add(ComponentTypeID<T0>.Value);
+        _disabled.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresent<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+        _present.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresentRW<T0, T1>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+        _present.Add(ComponentTypeID<T1>.Value);
+        _rw.Add(ComponentTypeID<T1>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAll<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+        _all.Add(ComponentTypeID<T1>.Value);
+        _all.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAllRW<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _all.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+        _all.Add(ComponentTypeID<T1>.Value);
+        _rw.Add(ComponentTypeID<T1>.Value);
+        _all.Add(ComponentTypeID<T2>.Value);
+        _rw.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Any' filter of the query.
+    /// Targets entities that have at least one of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAny<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _any.Add(ComponentTypeID<T0>.Value);
+        _any.Add(ComponentTypeID<T1>.Value);
+        _any.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Absent' filter of the query.
+    /// Targets entities that do not have any of the specified component types.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAbsent<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _absent.Add(ComponentTypeID<T0>.Value);
+        _absent.Add(ComponentTypeID<T1>.Value);
+        _absent.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'None' filter of the query.
+    /// Targets entities that do not have any of the specified component types, or those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithNone<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _none.Add(ComponentTypeID<T0>.Value);
+        _none.Add(ComponentTypeID<T1>.Value);
+        _none.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Disabled' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithDisabled<T0, T1, T2>()
+        where T0 : unmanaged, IEnableableComponent
+        where T1 : unmanaged, IEnableableComponent
+        where T2 : unmanaged, IEnableableComponent
+    {
+        _disabled.Add(ComponentTypeID<T0>.Value);
+        _disabled.Add(ComponentTypeID<T1>.Value);
+        _disabled.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresent<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+        _present.Add(ComponentTypeID<T1>.Value);
+        _present.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresentRW<T0, T1, T2>()
+        where T0 : unmanaged, IComponent
+        where T1 : unmanaged, IComponent
+        where T2 : unmanaged, IComponent
+    {
+        _present.Add(ComponentTypeID<T0>.Value);
+        _rw.Add(ComponentTypeID<T0>.Value);
+        _present.Add(ComponentTypeID<T1>.Value);
+        _rw.Add(ComponentTypeID<T1>.Value);
+        _present.Add(ComponentTypeID<T2>.Value);
+        _rw.Add(ComponentTypeID<T2>.Value);
+
+        return this;
+    }
+
+}

src/Runtime/Ghost.Entities/Templates/QueryBuilder.With.tt

@@ -0,0 +1,142 @@
+<#@ template language="C#" #>
+<#@ output extension="gen.cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ include file="Helpers.ttinclude" #>
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public ref partial struct QueryBuilder
+{
+<# for (var i = 1; i <= 3; i++)
+{
+    var generics = AppendGenerics(i);
+    var restrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IComponent", 2);
+    var enableRestrictions = AppendGenericRestrictionsMultiline(i, "unmanaged, IEnableableComponent", 2);
+#>
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAll<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _all.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'All' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAllRW<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _all.Add(ComponentTypeID<T<#= j #>>.Value);
+        _rw.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Any' filter of the query.
+    /// Targets entities that have at least one of the specified component types and those component(s) must be enabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAny<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _any.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Absent' filter of the query.
+    /// Targets entities that do not have any of the specified component types.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithAbsent<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _absent.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'None' filter of the query.
+    /// Targets entities that do not have any of the specified component types, or those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithNone<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _none.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Disabled' filter of the query.
+    /// Targets entities that have all of the specified component types and those component(s) are disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithDisabled<<#= generics #>>()
+<#= enableRestrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _disabled.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresent<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _present.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the specified component type(s) to the 'Present' filter of the query and requires read-write access.
+    /// Targets entities that have all of the specified component types, regardless of whether those component(s) are enabled or disabled.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public QueryBuilder WithPresentRW<<#= generics #>>()
+<#= restrictions #>
+    {
+<# for (var j = 0; j < i; j++) { #>
+        _present.Add(ComponentTypeID<T<#= j #>>.Value);
+        _rw.Add(ComponentTypeID<T<#= j #>>.Value);
+<# } #>
+
+        return this;
+    }
+
+<# } #>
+}

src/Runtime/Ghost.Entities/World.cs

@@ -0,0 +1,240 @@
+using Ghost.Core;
+using Misaki.HighPerformance.Jobs;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Entities;
+
+public partial class World
+{
+    private static readonly List<World?> s_worlds = new(4);
+    private static readonly Queue<Identifier<World>> s_freeWorldSlots = new();
+
+    internal static Identifier<Archetype> EmptyArchetypeID => new(0);
+
+    public static int WorldCount => s_worlds.Count - s_freeWorldSlots.Count;
+
+    public static World Create(JobScheduler? jobScheduler = null, int entityCapacity = 16)
+    {
+        lock (s_worlds)
+        {
+            if (s_freeWorldSlots.TryDequeue(out var index))
+            {
+                s_worlds[index.Value] = new World(index, entityCapacity, jobScheduler);
+            }
+            else
+            {
+                index = new Identifier<World>(s_worlds.Count);
+                s_worlds.Add(new World(index, entityCapacity, jobScheduler));
+            }
+
+            return s_worlds[index.Value]!;
+        }
+    }
+
+    public static void Destroy(Identifier<World> id)
+    {
+        lock (s_worlds)
+        {
+            if (id.Value < 0 || id.Value >= s_worlds.Count)
+            {
+                return;
+            }
+
+            var world = s_worlds[id.Value];
+            world?.Dispose();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static World GetWorldUncheck(Identifier<World> id)
+    {
+#if DEBUG || GHOST_EDITOR
+        if (id.Value < 0 || id.Value >= s_worlds.Count)
+        {
+            throw new ArgumentOutOfRangeException(nameof(id), "World ID is out of range.");
+        }
+
+        var world = s_worlds[id.Value];
+        return world is null ? throw new InvalidOperationException("World not found.") : world;
+#else
+        return s_worlds[id.Value]!;
+#endif
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static World? GetWorld(Identifier<World> id)
+    {
+        if (id.Value < 0 || id.Value >= s_worlds.Count)
+        {
+            return null;
+        }
+
+        return s_worlds[id.Value];
+    }
+}
+
+public partial class World : IDisposable, IEquatable<World>
+{
+    private readonly Identifier<World> _id;
+    private readonly JobScheduler? _jobScheduler;
+
+    private readonly EntityManager _entityManager;
+    private readonly EntityCommandBuffer _entityCommandBuffer;
+    private readonly EntityCommandBuffer[]? _threadLocalECBs;
+
+    private readonly ComponentManager _componentManager;
+    private readonly SystemManager _systemManager;
+
+    private int _version;
+    private bool _disposed = false;
+
+    /// <summary>
+    /// Gets the unique identifier of this world.
+    /// </summary>
+    public Identifier<World> ID => _id;
+
+    /// <summary>
+    /// Gets the job scheduler associated with this world.
+    /// </summary>
+    public JobScheduler? JobScheduler => _jobScheduler;
+
+    /// <summary>
+    /// Gets the publicntity manager for this world.
+    /// </summary>
+    public EntityManager EntityManager => _entityManager;
+
+    /// <summary>
+    /// Gets the component manager for this world.
+    /// </summary>
+    public ComponentManager ComponentManager => _componentManager;
+
+    /// <summary>
+    /// Gets the system manager for this world.
+    /// </summary>
+    public SystemManager SystemManager => _systemManager;
+
+    /// <summary>
+    /// Gets the current version number of the world.
+    /// </summary>
+    public int Version => Interlocked.CompareExchange(ref _version, 0, 0);
+
+    /// <summary>
+    /// Gets the main entity command buffer for this world.
+    /// </summary>
+    /// <remarks>
+    /// Use <see cref="GetThreadLocalEntityCommandBuffer(int)"/> to get thread-local command buffers for multi-threaded jobs.
+    /// </remarks>
+    public EntityCommandBuffer EntityCommandBuffer => _entityCommandBuffer;
+
+    private World(Identifier<World> id, int entityCapacity, JobScheduler? jobScheduler)
+    {
+        _id = id;
+        _jobScheduler = jobScheduler;
+
+        _entityManager = new EntityManager(this, entityCapacity);
+        _entityCommandBuffer = new EntityCommandBuffer(_entityManager);
+
+        _componentManager = new ComponentManager(this);
+        _systemManager = new SystemManager(this);
+
+        if (jobScheduler != null)
+        {
+            _threadLocalECBs = new EntityCommandBuffer[jobScheduler.WorkerCount];
+            for (var i = 0; i < jobScheduler.WorkerCount; i++)
+            {
+                _threadLocalECBs[i] = new EntityCommandBuffer(_entityManager);
+            }
+        }
+    }
+
+    ~World()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void PlaybackEntityCommandBuffers()
+    {
+        _entityCommandBuffer.Playback();
+
+        if (_threadLocalECBs != null)
+        {
+            for (var i = 0; i < _threadLocalECBs.Length; i++)
+            {
+                _threadLocalECBs[i].Playback();
+            }
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal int AdvanceVersion()
+    {
+        return Interlocked.Increment(ref _version);
+    }
+
+    /// <summary>
+    /// Gets the thread-local entity command buffer for the specified thread index.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public EntityCommandBuffer GetThreadLocalEntityCommandBuffer(int threadIndex)
+    {
+        if (_threadLocalECBs == null)
+        {
+            throw new InvalidOperationException("This world does not have a JobScheduler associated with it.");
+        }
+
+        return _threadLocalECBs[threadIndex];
+    }
+
+    public bool Equals(World? other)
+    {
+        return other is not null && _id == other._id;
+    }
+
+    public override int GetHashCode()
+    {
+        return _id.GetHashCode();
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is World other && Equals(other);
+    }
+
+    public static bool operator ==(World? left, World? right)
+    {
+        return left?.Equals(right) ?? right is null;
+    }
+
+    public static bool operator !=(World? left, World? right)
+    {
+        return !(left == right);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _entityManager.Dispose();
+        _entityCommandBuffer.Dispose();
+
+        if (_threadLocalECBs != null)
+        {
+            foreach (var v in _threadLocalECBs)
+            {
+                v.Dispose();
+            }
+        }
+
+        s_freeWorldSlots.Enqueue(_id);
+        s_worlds[_id] = null;
+
+        _disposed = true;
+
+        GC.SuppressFinalize(this);
+    }
+}
+

src/Runtime/Ghost.Generator/ComponentRegistrationGenerator.cs

@@ -0,0 +1,89 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Ghost.Generator
+{
+    // TODO: this should be per assembly, not global
+    [Generator]
+    public class ComponentRegistrationGenerator : IIncrementalGenerator
+    {
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            // 1. Pipeline: Find all structs implementing IComponent
+            var componentCandidates = context.SyntaxProvider
+                .CreateSyntaxProvider(
+                    predicate: (s, _) => s is StructDeclarationSyntax,
+                    transform: GetComponentSymbol)
+                .Where(symbol => symbol != null)
+                .Collect();
+
+            // 4. Output: Generate the source using both pieces of data at once
+            context.RegisterSourceOutput(componentCandidates, GenerateRegistrationCode);
+        }
+
+        // Extraction Logic for Components
+        private static INamedTypeSymbol GetComponentSymbol(GeneratorSyntaxContext ctx, CancellationToken _)
+        {
+            var structSyntax = (StructDeclarationSyntax)ctx.Node;
+            if (!(ctx.SemanticModel.GetDeclaredSymbol(structSyntax) is INamedTypeSymbol symbol))
+            {
+                return null;
+            }
+
+            var iComponentSymbol = ctx.SemanticModel.Compilation.GetTypeByMetadataName("Ghost.Entities.IComponent");
+            if (iComponentSymbol == null)
+            {
+                return null;
+            }
+
+            foreach (var iface in symbol.AllInterfaces)
+            {
+                if (SymbolEqualityComparer.Default.Equals(iface, iComponentSymbol))
+                {
+                    return symbol;
+                }
+            }
+
+            return null;
+        }
+
+        // The Generation Logic (Stateless)
+        private static void GenerateRegistrationCode(SourceProductionContext context, ImmutableArray<INamedTypeSymbol> components)
+        {
+            if (components.IsDefaultOrEmpty)
+            {
+                return;
+            }
+
+            var name = $"g_component_registration";
+
+            var sb = new StringBuilder();
+            sb.Append($@"
+[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+internal static class {name}
+{{
+    [global::System.Runtime.CompilerServices.ModuleInitializer]
+    public static void RegisterIComponentTypes()
+    {{");
+
+        foreach (var symbol in components.Distinct(SymbolEqualityComparer.Default))
+        {
+            if (symbol is null) continue;
+
+            sb.Append($@"
+        global::Ghost.Entities.ComponentRegistry.GetOrRegisterComponentID<{symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}>();");
+        }
+
+        sb.Append(@"
+    }
+}");
+
+            context.AddSource($"{name}.gen.cs", SourceText.From(sb.ToString(), Encoding.UTF8));
+        }
+    }
+}

src/Runtime/Ghost.Generator/ComponentSerializationGenerator.cs

@@ -0,0 +1,229 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+
+namespace Ghost.Generator
+{
+    [Generator]
+    public class ComponentSerializationGenerator : IIncrementalGenerator
+    {
+        private string GetJsonWriteCall(ITypeSymbol type, string fieldName)
+        {
+            switch (type.SpecialType)
+            {
+                case SpecialType.System_Byte:
+                case SpecialType.System_SByte:
+                case SpecialType.System_Int16:
+                case SpecialType.System_Int32:
+                case SpecialType.System_Int64:
+                case SpecialType.System_Single:
+                case SpecialType.System_Double:
+                case SpecialType.System_Decimal:
+                case SpecialType.System_UInt64:
+                case SpecialType.System_UInt16:
+                case SpecialType.System_UInt32:
+                case SpecialType.System_IntPtr:
+                case SpecialType.System_UIntPtr:
+                    return $@"writer.WriteNumber(""{fieldName}"", value.{fieldName});";
+                case SpecialType.System_Boolean:
+                    return $@"writer.WriteBoolean(""{fieldName}"", value.{fieldName});";
+                case SpecialType.System_Char:
+                    return $@"writer.WriteString(""{fieldName}"", [value.{fieldName}]);";
+                case SpecialType.System_String:
+                    return $@"writer.WriteString(""{fieldName}"", value.{fieldName});";
+            }
+
+            return $@"writer.WritePropertyName(""{fieldName}""); global::System.Text.Json.JsonSerializer.Serialize(writer, value.{fieldName}, options);";
+        }
+
+        private string GetJsonReadCall(ITypeSymbol type)
+        {
+            switch (type.SpecialType)
+            {
+                case SpecialType.System_Byte: return "reader.GetByte()";
+                case SpecialType.System_SByte: return "reader.GetSByte()";
+                case SpecialType.System_Int16: return "reader.GetInt16()";
+                case SpecialType.System_Int32: return "reader.GetInt32()";
+                case SpecialType.System_Int64: return "reader.GetInt64()";
+                case SpecialType.System_Single: return "reader.GetSingle()";
+                case SpecialType.System_Double: return "reader.GetDouble()";
+                case SpecialType.System_Decimal: return "reader.GetDecimal()";
+                case SpecialType.System_UInt16: return "reader.GetUInt16()";
+                case SpecialType.System_UInt32: return "reader.GetUInt32()";
+                case SpecialType.System_UInt64: return "reader.GetUInt64()";
+                // Note: the size of IntPtr and UIntPtr varies by platform, we use Int64/UInt64 to ensure compatibility
+                case SpecialType.System_IntPtr: return "reader.GetInt64()";
+                case SpecialType.System_UIntPtr: return "reader.GetUInt64()";
+                case SpecialType.System_Boolean: return "reader.GetBoolean()";
+                case SpecialType.System_Char: return "reader.GetString()[0]";
+                case SpecialType.System_String: return "reader.GetString()";
+            }
+
+            return $"global::System.Text.Json.JsonSerializer.Deserialize<{type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}>(ref reader, options)";
+        }
+
+        private void GenerateJsonSerializer(SourceProductionContext context, ImmutableArray<INamedTypeSymbol> symbols)
+        {
+            var sbWrites = new StringBuilder();
+            var sbReads = new StringBuilder();
+
+            foreach (var symbol in symbols)
+            {
+                var namespaceName = symbol.ContainingNamespace.ToDisplayString();
+                var structName = symbol.Name;
+                var fullTypeName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+
+                // 1. Build Field Logic (Same as before)
+                sbWrites.Clear();
+                sbReads.Clear();
+
+                var fields = symbol.GetMembers()
+                    .OfType<IFieldSymbol>()
+                    .Where(f => !f.IsStatic && f.DeclaredAccessibility == Accessibility.Public);
+
+                foreach (var field in fields)
+                {
+                    // Note: GetJsonWriteCall returns a string ending with ";"
+                    var writeCall = GetJsonWriteCall(field.Type, field.Name);
+                    if (writeCall != null)
+                    {
+                        sbWrites.Append("            "); // Indentation
+                        sbWrites.AppendLine(writeCall);
+                    }
+
+                    var readCall = GetJsonReadCall(field.Type);
+                    if (readCall != null)
+                    {
+                        // Note the double quotes ""{field.Name}"" for the case string
+                        sbReads.Append("                    "); // Indentation
+                        sbReads.AppendLine($@"case ""{field.Name}"": result.{field.Name} = {readCall}; break;");
+                    }
+                }
+
+                // 2. The Main Template using $@
+                // Watch the double braces {{ }} and double quotes "" ""
+                var sourceCode = $@"// <auto-generated/>
+#nullable enable
+
+namespace {namespaceName}
+{{
+    public unsafe static class {structName}_Serializer
+    {{
+        [global::System.Runtime.CompilerServices.ModuleInitializer]
+        internal static void Init() 
+        {{
+             var id = Ghost.Entities.ComponentTypeID<{fullTypeName}>.Value;
+             Ghost.Engine.IO.ComponentSerializerRegistry.Register(id, SerializeBinaryUnsafe,  SerializeJsonUnsafe);
+        }}
+
+        // ---------------------------------------------------------
+        // BINARY (Fast Path)
+        // ---------------------------------------------------------
+        [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static unsafe void SerializeBinaryUnsafe(global::System.IO.BinaryWriter writer, void* value)
+        {{
+            writer.Write(new global::System.ReadOnlySpan<byte>(value, sizeof({fullTypeName})));
+        }}
+
+        [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static void SerializeBinary(this global::System.IO.BinaryWriter writer, ref {fullTypeName} value)
+        {{
+            unsafe {{ writer.Write(new global::System.ReadOnlySpan<byte>(global::System.Runtime.CompilerServices.Unsafe.AsPointer(ref value), sizeof({fullTypeName}))); }}
+        }}
+
+        [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public static void DeserializeBinary(this global::System.IO.BinaryReader reader, ref {fullTypeName} value)
+        {{
+            unsafe {{ reader.Read(new global::System.Span<byte>(global::System.Runtime.CompilerServices.Unsafe.AsPointer(ref value), sizeof({fullTypeName}))); }}
+        }}
+
+        // ---------------------------------------------------------
+        // JSON WRITE
+        // ---------------------------------------------------------
+        public static unsafe void SerializeJsonUnsafe(System.Text.Json.Utf8JsonWriter writer, void* ptr, System.Text.Json.JsonSerializerOptions? options)
+        {{
+            SerializeJson(writer, ref *( {fullTypeName}*)ptr, options);
+        }}
+
+        public static void SerializeJson(this global::System.Text.Json.Utf8JsonWriter writer, ref {fullTypeName} value, global::System.Text.Json.JsonSerializerOptions? options)
+        {{
+            writer.WriteStartObject();
+{sbWrites}
+            writer.WriteEndObject();
+        }}
+
+        // ---------------------------------------------------------
+        // JSON READ
+        // ---------------------------------------------------------
+        public static {fullTypeName} DeserializeJson(ref global::System.Text.Json.Utf8JsonReader reader, global::System.Text.Json.JsonSerializerOptions? options)
+        {{
+            var result = default({fullTypeName});
+
+            if (reader.TokenType != global::System.Text.Json.JsonTokenType.StartObject) throw new global::System.Text.Json.JsonException();
+
+            while (reader.Read())
+            {{
+                if (reader.TokenType == global::System.Text.Json.JsonTokenType.EndObject) return result;
+                if (reader.TokenType != global::System.Text.Json.JsonTokenType.PropertyName) throw new global::System.Text.Json.JsonException();
+
+                var propName = reader.GetString();
+                reader.Read();
+
+                switch (propName)
+                {{
+{sbReads}
+                    default: reader.Skip(); break;
+                }}
+            }}
+            return result;
+        }}
+    }}
+}}";
+
+                context.AddSource($"{structName}.Serializer.gen.cs", sourceCode);
+            }
+        }
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            return;
+
+            var componentCandidates = context.SyntaxProvider
+                .CreateSyntaxProvider(
+                    predicate: (syntaxNode, _) => syntaxNode is StructDeclarationSyntax,
+                    transform: (ctx, _) =>
+                    {
+                        var structSyntax = (StructDeclarationSyntax)ctx.Node;
+
+                        if (!(ctx.SemanticModel.GetDeclaredSymbol(structSyntax) is INamedTypeSymbol symbol))
+                        {
+                            return null;
+                        }
+
+                        var compilation = ctx.SemanticModel.Compilation;
+                        var iComponentSymbol = compilation.GetTypeByMetadataName("Ghost.Entities.IComponent");
+
+                        if (iComponentSymbol == null)
+                        {
+                            return null;
+                        }
+
+                        foreach (var iface in symbol.AllInterfaces)
+                        {
+                            if (SymbolEqualityComparer.Default.Equals(iface, iComponentSymbol))
+                            {
+                                return symbol;
+                            }
+                        }
+
+                        return null;
+                    })
+                .Where(symbol => symbol != null)
+                .Collect();
+
+            context.RegisterSourceOutput(componentCandidates, GenerateJsonSerializer);
+        }
+    }
+}

src/Runtime/Ghost.Generator/Ghost.Generator.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Shader\**" />
+    <EmbeddedResource Remove="Shader\**" />
+    <None Remove="Shader\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="4.14.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+  </ItemGroup>
+
+</Project>

src/Runtime/Ghost.Graphics/AssemblyInfo.cs

@@ -0,0 +1,18 @@
+global using static TerraFX.Interop.DirectX.D3D12;
+global using static TerraFX.Interop.DirectX.DirectX;
+global using static TerraFX.Interop.DirectX.DXGI;
+global using static TerraFX.Interop.Windows.Windows;
+
+using Ghost.Core.Attributes;
+using System.Runtime.CompilerServices;
+using System.Runtime.Versioning;
+
+[assembly: InternalsVisibleTo("Ghost.Engine")]
+[assembly: InternalsVisibleTo("Ghost.Editor")]
+[assembly: InternalsVisibleTo("Ghost.Editor.Core")]
+[assembly: InternalsVisibleTo("Ghost.Graphics.Test")]
+[assembly: InternalsVisibleTo("Ghost.Graphics.Test-Winui")]
+[assembly: SupportedOSPlatform("windows10.0.19041.0")]
+
+
+[assembly: EngineAssembly]

src/Runtime/Ghost.Graphics/Contracts/IRenderOutput.cs

@@ -0,0 +1,43 @@
+using Ghost.Core;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.RHI;
+
+namespace Ghost.Graphics.Contracts;
+
+public interface IRenderOutput
+{
+    ViewportDesc Viewport
+    {
+        get; set;
+    }
+
+    RectDesc Scissor
+    {
+        get; set;
+    }
+
+    /// <summary>
+    /// Gets a handle to the current render target texture.
+    /// </summary>
+    /// <returns>A handle to the texture that is currently set as the render target.</returns>
+    Handle<Texture> GetRenderTarget();
+
+    /// <summary>
+    /// Begins a rendering operation using the specified command buffer. Typically this will include resource barriers,
+    /// </summary>
+    /// <param name="cmd">The command buffer that records rendering commands.</param>
+    /// 
+    void BeginRender(ICommandBuffer cmd);
+    /// <summary>
+    /// Finalizes the rendering process using the specified command buffer.
+    /// </summary>
+    /// <param name="cmd">The command buffer that contains the rendering commands to be finalized.</param>
+    void EndRender(ICommandBuffer cmd);
+
+    /// <summary>
+    /// Displays the current frame to the output device or screen.
+    /// </summary>
+    /// <remarks>Call this method after rendering operations to present the rendered content. The exact
+    /// behavior may depend on the underlying graphics implementation or device.</remarks>
+    void Present();
+}

src/Runtime/Ghost.Graphics/Contracts/IRenderPass.cs

@@ -0,0 +1,13 @@
+using Ghost.Core;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.RenderGraphModule;
+using Ghost.Graphics.RHI;
+
+namespace Ghost.Graphics.Contracts;
+
+public interface IRenderPass
+{
+    void Initialize(ref readonly RenderingContext ctx);
+    void Build(RenderGraph graph, Identifier<RGTexture> backbuffer);
+    void Cleanup(IResourceDatabase resourceDatabase);
+}

src/Runtime/Ghost.Graphics/Contracts/IShaderCompiler.cs

@@ -0,0 +1,150 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Ghost.Graphics.Contracts;
+
+public struct ShaderCompileResult : IDisposable
+{
+    public UnsafeArray<byte> bytecode;
+    public ShaderReflectionData reflectionData;
+
+    public readonly bool IsCreated => bytecode.IsCreated;
+
+    public void Dispose()
+    {
+        bytecode.Dispose();
+    }
+}
+
+public struct GraphicsCompiledResult : IDisposable
+{
+    public ShaderCompileResult tsResult;
+    public ShaderCompileResult msResult;
+    public ShaderCompileResult psResult;
+
+    public void Dispose()
+    {
+        tsResult.Dispose();
+        msResult.Dispose();
+        psResult.Dispose();
+    }
+}
+
+public ref struct ShaderCompilationConfig
+{
+    public ReadOnlySpan<string> defines;
+    public ReadOnlySpan<string> includes;
+    public string shaderPath;
+    public string entryPoint;
+    public string? injectedCode;
+    public ShaderStage stage;
+    public CompilerTier tier;
+    public CompilerOptimizeLevel optimizeLevel;
+    public CompilerOption options;
+}
+
+public enum CompilerTier
+{
+    Tier0,
+    Tier1,
+    Tier2
+}
+
+public enum CompilerOptimizeLevel
+{
+    O0,
+    O1,
+    O2,
+    O3
+}
+
+[Flags]
+public enum CompilerOption
+{
+    None = 0,
+    KeepDebugInfo = 1 << 0,
+    KeepReflections = 1 << 1,
+    WarnAsError = 1 << 2,
+    SpirvCrossCompile = 1 << 3
+}
+
+public enum ShaderStage
+{
+    TaskShader,
+    MeshShader,
+    PixelShader,
+    ComputeShader
+}
+
+public enum ShaderInputType
+{
+    ConstantBuffer,
+    Texture,
+    Sampler,
+    UAV,
+    StructuredBuffer,
+    ByteAddressBuffer,
+    RWStructuredBuffer,
+    RWByteAddressBuffer
+}
+
+public struct ResourceBindingInfo
+{
+    public string Name
+    {
+        get; set;
+    }
+
+    public ShaderInputType Type
+    {
+        get; set;
+    }
+
+    public uint BindPoint
+    {
+        get; set;
+    }
+
+    public uint BindCount
+    {
+        get; set;
+    }
+
+    public uint Space
+    {
+        get; set;
+    }
+
+    public uint Size
+    {
+        get; set;
+    }
+
+    public IReadOnlyList<CBufferPropertyInfo>? Properties
+    {
+        get; set;
+    }
+}
+
+public readonly struct ShaderReflectionData
+{
+    public List<ResourceBindingInfo> ResourcesBindings
+    {
+        get;
+    }
+
+    public ShaderReflectionData()
+    {
+        ResourcesBindings = new List<ResourceBindingInfo>();
+    }
+}
+
+public interface IShaderCompiler : IDisposable
+{
+    Result<ShaderCompileResult> Compile(ref readonly ShaderCompilationConfig config, Allocator allocator);
+    Result<GraphicsCompiledResult> CompilePass(ref readonly PassDescriptor descriptor, ref readonly ShaderCompilationConfig additionalConfig, Key64<ShaderVariant> key);
+    Result<GraphicsCompiledResult, Error> LoadCompiledCache(Key64<ShaderVariant> key);
+}

src/Runtime/Ghost.Graphics/Contracts/ISwapChainPanelNative.cs

@@ -0,0 +1,74 @@
+using System.Runtime.InteropServices;
+using TerraFX.Interop.Windows;
+
+namespace Ghost.Graphics.Contracts;
+
+public unsafe readonly struct ISwapChainPanelNative : ISwapChainPanelNative.Interface, IDisposable
+{
+    [ComImport]
+    [Guid("63aad0b8-7c24-40ff-85a8-640d944cc325")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface Interface
+    {
+        // IUnknown: QueryInterface, AddRef, Release
+        void QueryInterface(in Guid riid, out IntPtr ppvObject);
+        uint AddRef();
+        uint Release();
+
+        // SetSwapChain is the 4th slot in the vtable (0-based index 3)
+        int SetSwapChain(IntPtr swapChainPtr);
+    }
+
+    private readonly IntPtr _nativePtr;
+
+    public ISwapChainPanelNative(IntPtr nativePtr)
+    {
+        _nativePtr = nativePtr;
+    }
+
+    public void QueryInterface(in Guid riid, out nint ppvObject)
+    {
+        throw new NotImplementedException();
+    }
+
+    public uint AddRef()
+    {
+        throw new NotImplementedException();
+    }
+
+    public uint Release()
+    {
+        throw new NotImplementedException();
+    }
+
+    public static ISwapChainPanelNative FromSwapChainPanel(object panel)
+    {
+        // Get the IUnknown/IInspectable pointer
+        var unknown = Marshal.GetIUnknownForObject(panel);
+        try
+        {
+            // Query for ISwapChainPanelNative
+            var iid = typeof(Interface).GUID;
+            var result = Marshal.QueryInterface(unknown, in iid, out var nativePtr);
+            if (result < 0)
+            {
+                Marshal.ThrowExceptionForHR(result);
+            }
+
+            return new ISwapChainPanelNative(nativePtr);
+        }
+        finally
+        {
+            Marshal.Release(unknown);
+        }
+    }
+
+    public int SetSwapChain(IntPtr swapChainPtr)
+    {
+        var vtbl = *(void***)_nativePtr;
+        var setSwapChainFn = (delegate* unmanaged<IntPtr, IntPtr, int>)vtbl[3];
+        return setSwapChainFn(_nativePtr, swapChainPtr);
+    }
+
+    public void Dispose() => Marshal.Release(_nativePtr);
+}

src/Runtime/Ghost.Graphics/Core/Camera.cs

@@ -0,0 +1,5 @@
+namespace Ghost.Graphics.Core;
+
+public class Camera
+{
+}

src/Runtime/Ghost.Graphics/Core/Common.cs

@@ -0,0 +1,150 @@
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.Mathematics;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using TerraFX.Interop.DirectX;
+
+namespace Ghost.Graphics.Core;
+
+/// <summary>
+/// Represents a color with 4 bytes components.
+/// </summary>
+[StructLayout(LayoutKind.Sequential, Size = 4)]
+public struct Color32 : IEquatable<Color32>
+{
+    public byte r;
+    public byte g;
+    public byte b;
+    public byte a;
+
+    public Color32(byte r, byte g, byte b, byte a)
+    {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+
+    public Color32(Color color)
+        : this(color.R, color.G, color.B, color.A)
+    {
+    }
+
+    public Color32(Color128 color128)
+        : this((byte)(color128.r * 255.0f), (byte)(color128.g * 255.0f), (byte)(color128.b * 255.0f), (byte)(color128.a * 255.0f))
+    {
+    }
+
+    public Color32(float4 v)
+        : this((byte)(v.x * 255.0f), (byte)(v.y * 255.0f), (byte)(v.z * 255.0f), (byte)(v.w * 255.0f))
+    {
+    }
+
+    public readonly bool Equals(Color32 other)
+    {
+        return r == other.r && g == other.g && b == other.b && a == other.a;
+    }
+
+    public override readonly bool Equals(object? obj)
+    {
+        return obj is Color32 color && Equals(color);
+    }
+
+    public override readonly int GetHashCode()
+    {
+        return HashCode.Combine(r, g, b, a);
+    }
+
+    public static bool operator ==(Color32 left, Color32 right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Color32 left, Color32 right)
+    {
+        return !(left == right);
+    }
+}
+
+/// <summary>
+/// Represents a color with 16 bytes components.
+/// </summary>
+[StructLayout(LayoutKind.Sequential, Size = 16)]
+public struct Color128 : IEquatable<Color128>
+{
+    public float r;
+    public float g;
+    public float b;
+    public float a;
+
+    public Color128(float r, float g, float b, float a)
+    {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+
+    public Color128(Color color)
+        : this(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f, color.A / 255.0f)
+    {
+    }
+
+    public Color128(Color32 color32)
+        : this(color32.r / 255.0f, color32.g / 255.0f, color32.b / 255.0f, color32.a / 255.0f)
+    {
+    }
+
+    public Color128(float4 v)
+        : this(v.x, v.y, v.z, v.w)
+    {
+    }
+
+    public readonly bool Equals(Color128 other)
+    {
+        return r.Equals(other.r) && g.Equals(other.g) && b.Equals(other.b) && a.Equals(other.a);
+    }
+
+    public override readonly bool Equals(object? obj)
+    {
+        return obj is Color128 color && Equals(color);
+    }
+
+    public readonly override int GetHashCode()
+    {
+        return HashCode.Combine(r, g, b, a);
+    }
+
+    public static bool operator ==(Color128 left, Color128 right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(Color128 left, Color128 right)
+    {
+        return !(left == right);
+    }
+}
+
+
+[StructLayout(LayoutKind.Sequential)]
+public struct Vertex
+{
+    public static class Semantic
+    {
+        public const DXGI_FORMAT ALIGNED_FORMAT = DXGI_FORMAT.DXGI_FORMAT_R32G32B32A32_FLOAT;
+        public const int COUNT = 5;
+
+        public static readonly FixedText32 Position = new("POSITION");
+        public static readonly FixedText32 Normal = new("NORMAL");
+        public static readonly FixedText32 Tangent = new("TANGENT");
+        public static readonly FixedText32 Uv = new("TEXCOORD");
+        public static readonly FixedText32 Color = new("COLOR");
+    }
+
+    public float4 position;
+    public float4 normal;
+    public float4 tangent;
+    public float4 uv;
+    public Color128 color;
+}

src/Runtime/Ghost.Graphics/Core/DxcShaderCompiler.cs

@@ -0,0 +1,520 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Core.Utilities;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.Utilities;
+using System.Runtime.InteropServices;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Interop.DirectX.DXC;
+
+namespace Ghost.Graphics.Core;
+
+internal sealed partial class DxcShaderCompiler
+{
+    private static string GetProfileString(ShaderStage stage, CompilerTier version)
+    {
+        return (stage, version) switch
+        {
+            (ShaderStage.TaskShader, CompilerTier.Tier0) => "as_6_6",
+            (ShaderStage.PixelShader, CompilerTier.Tier0) => "ps_6_6",
+            (ShaderStage.MeshShader, CompilerTier.Tier0) => "ms_6_6",
+            (ShaderStage.ComputeShader, CompilerTier.Tier0) => "cs_6_6",
+            (ShaderStage.TaskShader, CompilerTier.Tier1) => "as_6_7",
+            (ShaderStage.PixelShader, CompilerTier.Tier1) => "ps_6_7",
+            (ShaderStage.MeshShader, CompilerTier.Tier1) => "ms_6_7",
+            (ShaderStage.ComputeShader, CompilerTier.Tier1) => "cs_6_7",
+            (ShaderStage.TaskShader, CompilerTier.Tier2) => "as_6_8",
+            (ShaderStage.PixelShader, CompilerTier.Tier2) => "ps_6_8",
+            (ShaderStage.MeshShader, CompilerTier.Tier2) => "ms_6_8",
+            (ShaderStage.ComputeShader, CompilerTier.Tier2) => "cs_6_8",
+            _ => throw new ArgumentOutOfRangeException(nameof(stage), "Unsupported shader stage or compiler version")
+        };
+    }
+
+    private static string GetOptimizeLevelString(CompilerOptimizeLevel level)
+    {
+        return level switch
+        {
+            CompilerOptimizeLevel.O0 => DXC_ARG_OPTIMIZATION_LEVEL0,
+            CompilerOptimizeLevel.O1 => DXC_ARG_OPTIMIZATION_LEVEL1,
+            CompilerOptimizeLevel.O2 => DXC_ARG_OPTIMIZATION_LEVEL2,
+            CompilerOptimizeLevel.O3 => DXC_ARG_OPTIMIZATION_LEVEL3,
+            _ => throw new ArgumentOutOfRangeException(nameof(level), "Unsupported optimization level")
+        };
+    }
+
+    private static List<string> GetCompilerArguments(ref readonly ShaderCompilationConfig config)
+    {
+        var argsArray = new List<string>
+        {
+            "-T", GetProfileString(config.stage, config.tier),   // Target profile (ms_6_6, ps_6_6)
+            "-E", config.entryPoint,                                    // Entry point
+            "-HV", "2021",                                              // HLSL version 2021
+            "-enable-16bit-types",                                      // Enable 16-bit types
+            GetOptimizeLevelString(config.optimizeLevel),         // Optimization level
+        };
+
+        foreach (var define in config.defines)
+        {
+            argsArray.Add("-D");
+            argsArray.Add(define);
+        }
+
+        if (!config.options.HasFlag(CompilerOption.KeepDebugInfo))
+        {
+            argsArray.Add("-Qstrip_debug");
+        }
+
+        if (!config.options.HasFlag(CompilerOption.KeepReflections))
+        {
+            argsArray.Add("-Qstrip_reflect");
+        }
+
+        if (config.options.HasFlag(CompilerOption.WarnAsError))
+        {
+            argsArray.Add(DXC_ARG_WARNINGS_ARE_ERRORS);
+        }
+
+        if (config.options.HasFlag(CompilerOption.SpirvCrossCompile))
+        {
+            argsArray.Add("-spirv");
+        }
+
+        return argsArray;
+    }
+
+    private static Result<string, Error> GetFinalShaderCode(string shaderPath, ReadOnlySpan<string> includes, string? injectedCode)
+    {
+        string shaderCode;
+        if (shaderPath == "hlsl_block")
+        {
+            if (string.IsNullOrEmpty(injectedCode))
+            {
+                return Error.InvalidArgument;
+            }
+
+            shaderCode = string.Empty;
+        }
+        else
+        {
+            if (!File.Exists(shaderPath))
+            {
+                return Error.NotFound;
+            }
+
+            shaderCode = File.ReadAllText(shaderPath);
+        }
+
+        var sb = new System.Text.StringBuilder();
+        foreach (var includePath in includes)
+        {
+            sb.AppendLine($"#include \"{includePath}\"");
+        }
+        
+        if (!string.IsNullOrEmpty(injectedCode))
+        {
+            sb.AppendLine($"#line 1 \"hlsl_block\"");
+            sb.AppendLine(injectedCode);
+        }
+
+        if (!string.IsNullOrEmpty(shaderCode))
+        {
+            sb.AppendLine($"#line 1 \"{shaderPath}\"");
+            sb.AppendLine(shaderCode);
+        }
+
+        return sb.ToString();
+    }
+
+    private static ShaderInputType ToInputType(D3D_SHADER_INPUT_TYPE type)
+    {
+        return type switch
+        {
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_CBUFFER => ShaderInputType.ConstantBuffer,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_TBUFFER => ShaderInputType.Texture,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_TEXTURE => ShaderInputType.Texture,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_SAMPLER => ShaderInputType.Sampler,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWTYPED => ShaderInputType.UAV,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_STRUCTURED => ShaderInputType.StructuredBuffer,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_BYTEADDRESS => ShaderInputType.ByteAddressBuffer,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWSTRUCTURED => ShaderInputType.RWStructuredBuffer,
+            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWBYTEADDRESS => ShaderInputType.RWByteAddressBuffer,
+            _ => throw new ArgumentOutOfRangeException(nameof(type), "Unsupported shader input type")
+        };
+    }
+}
+
+internal sealed unsafe partial class DxcShaderCompiler : IShaderCompiler
+{
+    private UniquePtr<IDxcCompiler3> _compiler;
+    private UniquePtr<IDxcUtils> _utils;
+    // NOTE: This is just a temporary cache for compiled shader code. We will implement a proper disk cache later.
+    // TODO: This should be shader variant specific cache instead of pass specific.
+    private readonly Dictionary<Key64<ShaderVariant>, GraphicsCompiledResult> _compiledResults;
+
+    private bool _disposed;
+
+    public DxcShaderCompiler()
+    {
+        // Initialize DXC _compiler.Get() and _utils.Get()
+        var dxccID = CLSID.CLSID_DxcCompiler;
+        var dxcuID = CLSID.CLSID_DxcUtils;
+
+        IDxcCompiler3* pCompiler = default;
+        IDxcUtils* pUtils = default;
+        ThrowIfFailed(DxcCreateInstance(&dxccID, __uuidof(pCompiler), (void**)&pCompiler));
+        ThrowIfFailed(DxcCreateInstance(&dxcuID, __uuidof(pUtils), (void**)&pUtils));
+
+        _compiler.Attach(pCompiler);
+        _utils.Attach(pUtils);
+
+        _compiledResults = new Dictionary<Key64<ShaderVariant>, GraphicsCompiledResult>();
+    }
+
+    ~DxcShaderCompiler()
+    {
+        Dispose();
+    }
+
+    private Result<ShaderReflectionData> PerformDXCReflection(IDxcBlob* pReflectionBlob)
+    {
+        ID3D12ShaderReflection* pReflection = default;
+
+        try
+        {
+            // Create DXC _utils.Get() to parse reflection data
+            var dxcuID = CLSID.CLSID_DxcUtils;
+
+            // Create reflection interface from blob
+            var reflectionBuffer = new DxcBuffer
+            {
+                Ptr = pReflectionBlob->GetBufferPointer(),
+                Size = pReflectionBlob->GetBufferSize(),
+                Encoding = DXC_CP_ACP
+            };
+
+            ThrowIfFailed(_utils.Get()->CreateReflection(&reflectionBuffer, __uuidof(pReflection), (void**)&pReflection));
+
+            D3D12_SHADER_DESC shaderDesc;
+            ThrowIfFailed(pReflection->GetDesc(&shaderDesc));
+
+            var reflectionData = new ShaderReflectionData();
+
+            for (uint i = 0; i < shaderDesc.BoundResources; i++)
+            {
+                D3D12_SHADER_INPUT_BIND_DESC bindDesc;
+                ThrowIfFailed(pReflection->GetResourceBindingDesc(i, &bindDesc));
+
+                var resourceName = Marshal.PtrToStringUTF8((IntPtr)bindDesc.Name);
+                if (resourceName == null)
+                {
+                    return Result.Failure("Failed to get resource name from reflection data.");
+                }
+
+                var info = new ResourceBindingInfo
+                {
+                    Name = resourceName,
+                    Type = ToInputType(bindDesc.Type),
+                    BindPoint = bindDesc.BindPoint,
+                    BindCount = bindDesc.BindCount,
+                    Space = bindDesc.Space
+                };
+
+                switch (bindDesc.Type)
+                {
+                    case D3D_SHADER_INPUT_TYPE.D3D_SIT_CBUFFER:
+                        {
+                            var cbuffer = pReflection->GetConstantBufferByName(bindDesc.Name);
+                            D3D12_SHADER_BUFFER_DESC cbufferDesc;
+                            ThrowIfFailed(cbuffer->GetDesc(&cbufferDesc));
+
+                            var variables = new List<CBufferPropertyInfo>((int)cbufferDesc.Variables);
+
+                            // Now we iterate all variables for *every* cbuffer, not just b3
+                            for (uint j = 0; j < cbufferDesc.Variables; j++)
+                            {
+                                var variable = cbuffer->GetVariableByIndex(j);
+                                D3D12_SHADER_VARIABLE_DESC varDesc;
+                                variable->GetDesc(&varDesc);
+
+                                var variableName = Marshal.PtrToStringUTF8((IntPtr)varDesc.Name);
+                                if (variableName == null)
+                                {
+                                    continue;
+                                }
+
+                                variables.Add(new CBufferPropertyInfo
+                                {
+                                    Name = variableName,
+                                    StartOffset = varDesc.StartOffset,
+                                    Size = varDesc.Size
+                                });
+                            }
+
+                            info.Size = cbufferDesc.Size;
+                            info.Properties = variables;
+
+                            break;
+                        }
+
+                        // NOTE: Currently we do not support resource bindings yet, everything access through bindless heaps.
+                }
+
+                reflectionData.ResourcesBindings.Add(info);
+            }
+
+            return reflectionData;
+        }
+        finally
+        {
+            pReflection->Release();
+        }
+    }
+
+    public Result<ShaderCompileResult> Compile(ref readonly ShaderCompilationConfig config, Allocator allocator)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        using ComPtr<IDxcIncludeHandler> includeHandler = default;
+        using ComPtr<IDxcBlobEncoding> sourceBlob = default;
+
+        ThrowIfFailed(_utils.Get()->CreateDefaultIncludeHandler(includeHandler.GetAddressOf()));
+
+        var finalShaderCodeResult = GetFinalShaderCode(config.shaderPath, config.includes, config.injectedCode);
+        if (finalShaderCodeResult.IsFailure)
+        {
+            return Result.Failure(finalShaderCodeResult.Error);
+        }
+
+        var finalShaderCode = finalShaderCodeResult.Value;
+        fixed (byte* pCode = System.Text.Encoding.UTF8.GetBytes(finalShaderCode))
+        {
+            var sizeInBytes = System.Text.Encoding.UTF8.GetByteCount(finalShaderCode);
+            ThrowIfFailed(_utils.Get()->CreateBlobFromPinned(pCode, (uint)sizeInBytes, DXC_CP_UTF8, sourceBlob.GetAddressOf()));
+        }
+
+        var argsArray = GetCompilerArguments(in config);
+        var argPtrs = stackalloc char*[argsArray.Count];
+        for (var i = 0; i < argsArray.Count; i++)
+        {
+            argPtrs[i] = (char*)Marshal.StringToHGlobalUni(argsArray[i]);
+        }
+
+        using ComPtr<IDxcResult> result = default;
+
+        try
+        {
+            // Compile shader
+            var buffer = new DxcBuffer
+            {
+                Ptr = sourceBlob.Get()->GetBufferPointer(),
+                Size = sourceBlob.Get()->GetBufferSize(),
+                Encoding = DXC_CP_UTF8
+            };
+
+            var (iid, ppv) = Win32Utility.IID_PPV_ARGS(&result);
+            ThrowIfFailed(_compiler.Get()->Compile(&buffer, argPtrs, (uint)argsArray.Count, includeHandler, iid, ppv));
+
+            // Check compilation result
+            HRESULT hrStatus;
+            result.Get()->GetStatus(&hrStatus);
+            if (hrStatus.FAILED)
+            {
+                // Get error messages
+                IDxcBlobEncoding* pErrorBlob = default;
+                result.Get()->GetErrorBuffer(&pErrorBlob);
+
+                if (pErrorBlob != null)
+                {
+                    var errorMessage = Marshal.PtrToStringUTF8((IntPtr)pErrorBlob->GetBufferPointer());
+                    pErrorBlob->Release();
+
+                    return Result.Failure($"DXC shader compilation failed:\n{errorMessage}");
+                }
+                else
+                {
+                    return Result.Failure("DXC shader compilation failed with unknown error.");
+                }
+            }
+
+            // Get compiled bytecode
+            using ComPtr<IDxcBlob> bytecodeBlob = default;
+            ThrowIfFailed(result.Get()->GetResult(bytecodeBlob.GetAddressOf()));
+
+            ShaderReflectionData reflectionData = default;
+            if (config.options.HasFlag(CompilerOption.KeepReflections))
+            {
+                using ComPtr<IDxcBlob> reflection = default;
+                (iid, ppv) = Win32Utility.IID_PPV_ARGS(&reflection);
+
+                if (result.Get()->GetOutput(DXC_OUT_KIND.DXC_OUT_REFLECTION, iid, ppv, null).SUCCEEDED)
+                {
+                    reflectionData = PerformDXCReflection(reflection).GetValueOrDefault();
+                }
+            }
+
+            var bytecodeSize = bytecodeBlob.Get()->GetBufferSize();
+            var bytecode = new UnsafeArray<byte>((int)bytecodeSize, allocator);
+
+            NativeMemory.Copy(bytecodeBlob.Get()->GetBufferPointer(), bytecode.GetUnsafePtr(), bytecodeSize);
+
+            return new ShaderCompileResult
+            {
+                bytecode = bytecode,
+                reflectionData = reflectionData,
+            };
+        }
+        finally
+        {
+            for (var i = 0; i < argsArray.Count; i++)
+            {
+                Marshal.FreeHGlobal((nint)argPtrs[i]);
+            }
+        }
+    }
+
+    // TODO: This should be shader variant specific compile instead of pass specific.
+    // TODO: Build final shader code in memory before compiling.
+    public Result<GraphicsCompiledResult> CompilePass(ref readonly PassDescriptor descriptor, ref readonly ShaderCompilationConfig additionalConfig, Key64<ShaderVariant> key)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var defineCountInDescriptor = descriptor.defines?.Length ?? 0;
+        var fullDefines = new string[defineCountInDescriptor + additionalConfig.defines.Length];
+        descriptor.defines?.CopyTo(fullDefines);
+        additionalConfig.defines.CopyTo(fullDefines.AsSpan(defineCountInDescriptor));
+
+        ShaderCompileResult tsResult = default;
+        var tsEntry = descriptor.taskShader;
+        if (tsEntry.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines.AsSpan(),
+                includes = descriptor.includes.AsSpan(),
+                shaderPath = tsEntry.shader,
+                entryPoint = tsEntry.entry,
+                injectedCode = descriptor.hlsl + additionalConfig.injectedCode,
+                stage = ShaderStage.TaskShader,
+                tier = additionalConfig.tier,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config, Allocator.Persistent);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            tsResult = result.Value;
+        }
+
+        ShaderCompileResult msResult;
+        var msEntry = descriptor.meshShader;
+        if (msEntry.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines.AsSpan(),
+                includes = descriptor.includes.AsSpan(),
+                shaderPath = msEntry.shader,
+                entryPoint = msEntry.entry,
+                injectedCode = descriptor.hlsl + additionalConfig.injectedCode,
+                stage = ShaderStage.MeshShader,
+                tier = additionalConfig.tier,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config, Allocator.Persistent);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            msResult = result.Value;
+        }
+        else
+        {
+            return Result.Failure("Mesh shader expected.");
+        }
+
+        ShaderCompileResult psResult;
+        var psEntry = descriptor.pixelShader;
+        if (psEntry.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines.AsSpan(),
+                includes = descriptor.includes.AsSpan(),
+                shaderPath = psEntry.shader,
+                entryPoint = psEntry.entry,
+                injectedCode = descriptor.hlsl + additionalConfig.injectedCode,
+                stage = ShaderStage.PixelShader,
+                tier = additionalConfig.tier,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config, Allocator.Persistent);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            psResult = result.Value;
+        }
+        else
+        {
+            return Result.Failure("Pixel shader expected.");
+        }
+
+        var compiled = new GraphicsCompiledResult
+        {
+            tsResult = tsResult,
+            msResult = msResult,
+            psResult = psResult,
+        };
+
+        _compiledResults[key] = compiled;
+        return compiled;
+    }
+
+    public Result<GraphicsCompiledResult, Error> LoadCompiledCache(Key64<ShaderVariant> key)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (_compiledResults.TryGetValue(key, out var compiledResult))
+        {
+            return compiledResult;
+        }
+
+        return Error.NotFound;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        foreach (var kvp in _compiledResults)
+        {
+            kvp.Value.Dispose();
+        }
+
+        _compiler.Dispose();
+        _utils.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/Core/Keyword.cs

@@ -0,0 +1,128 @@
+using System.Runtime.Intrinsics;
+using TerraFX.Interop.Windows;
+using ElementType = uint;
+
+namespace Ghost.Graphics.Core;
+
+public unsafe struct LocalKeywordSet
+{
+    private const int _DATA_ARRAY_LENGTH = 4; // 4 * 32 = 128 bits
+    private const int _BITS_PER_ELEMENT = sizeof(ElementType) * 8;
+
+    private fixed ElementType _data[_DATA_ARRAY_LENGTH];
+
+    public void SetKeyword(int localIndex, bool enabled)
+    {
+        var index = localIndex / _BITS_PER_ELEMENT;
+        var bit = localIndex % _BITS_PER_ELEMENT;
+        if (enabled)
+        {
+            _data[index] |= (uint)(1 << bit);
+        }
+        else
+        {
+            _data[index] &= ~(uint)(1 << bit);
+        }
+    }
+
+    public bool IsKeywordEnabled(int localIndex)
+    {
+        var index = localIndex / _BITS_PER_ELEMENT;
+        var bit = localIndex % _BITS_PER_ELEMENT;
+        return (_data[index] & (uint)(1 << bit)) != 0;
+    }
+
+    public void Clear()
+    {
+        for (var i = 0; i < _DATA_ARRAY_LENGTH; i++)
+        {
+            _data[i] = 0;
+        }
+    }
+
+    public ulong GetHash64()
+    {
+        ulong hash = 14695981039346656037ul; // FNV Offset basis
+
+        for (var i = 0; i < _DATA_ARRAY_LENGTH; i++)
+        {
+            hash ^= _data[i];
+            hash *= 1099511628211ul; // FNV prime
+        }
+
+        return hash;
+    }
+
+    public override int GetHashCode()
+    {
+        var hash = 17;
+        for (var i = 0; i < _DATA_ARRAY_LENGTH; i++)
+        {
+            hash = hash * 31 + _data[i].GetHashCode();
+        }
+
+        return hash;
+    }
+
+
+    public static LocalKeywordSet operator |(in LocalKeywordSet a, in LocalKeywordSet b)
+    {
+        var result = default(LocalKeywordSet);
+
+        if (Vector128<ElementType>.IsSupported)
+        {
+            fixed (ElementType* pDataA = a._data)
+            fixed (ElementType* pDataB = b._data)
+            {
+                for (var i = 0; i < _DATA_ARRAY_LENGTH; i += Vector128<ElementType>.Count)
+                {
+                    var elementOffset = (nuint)i;
+                    var vecA = Vector128.LoadUnsafe(ref *pDataA, elementOffset);
+                    var vecB = Vector128.LoadUnsafe(ref *pDataB, elementOffset);
+                    var vecResult = Vector128.BitwiseOr(vecA, vecB);
+                    vecResult.StoreUnsafe(ref result._data[0], elementOffset);
+                }
+            }
+        }
+        else
+        {
+            for (var i = 0; i < _DATA_ARRAY_LENGTH; i++)
+            {
+                result._data[i] = a._data[i] | b._data[i];
+            }
+        }
+
+        return result;
+    }
+
+    public static LocalKeywordSet operator &(in LocalKeywordSet a, in LocalKeywordSet b)
+    {
+        var result = default(LocalKeywordSet);
+
+        if (Vector128<ElementType>.IsSupported)
+        {
+            fixed (ElementType* pDataA = a._data)
+            fixed (ElementType* pDataB = b._data)
+            {
+                for (var i = 0; i < _DATA_ARRAY_LENGTH; i += Vector128<ElementType>.Count)
+                {
+                    var elementOffset = (nuint)i;
+                    var vecA = Vector128.LoadUnsafe(ref *pDataA, elementOffset);
+                    var vecB = Vector128.LoadUnsafe(ref *pDataB, elementOffset);
+                    var vecResult = Vector128.BitwiseAnd(vecA, vecB);
+                    vecResult.StoreUnsafe(ref result._data[0], elementOffset);
+                }
+            }
+        }
+        else
+        {
+
+            for (var i = 0; i < _DATA_ARRAY_LENGTH; i++)
+            {
+                result._data[i] = a._data[i] & b._data[i];
+            }
+        }
+
+        return result;
+    }
+}

src/Runtime/Ghost.Graphics/Core/Material.cs

@@ -0,0 +1,286 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Graphics.Core;
+
+internal struct CBufferCache : IResourceReleasable
+{
+    private UnsafeArray<byte> _cpuData;
+    private Handle<GraphicsBuffer> _gpuResource;
+    private uint _size;
+
+    public readonly UnsafeArray<byte> CpuData => _cpuData;
+    public readonly Handle<GraphicsBuffer> GpuResource => _gpuResource;
+    public readonly uint Size => _size;
+
+    public readonly bool IsCreated => _size != 0 && _gpuResource.IsValid && _cpuData.IsCreated;
+
+    public CBufferCache(Handle<GraphicsBuffer> buffer, uint bufferSize)
+    {
+        _size = bufferSize;
+        _cpuData = new UnsafeArray<byte>((int)bufferSize, Allocator.Persistent);
+        _gpuResource = buffer;
+    }
+
+    public void ReleaseResource(IResourceDatabase database)
+    {
+        if (!IsCreated)
+        {
+            return;
+        }
+
+        _cpuData.Dispose();
+
+        database.ReleaseResource(GpuResource.AsResource());
+        _gpuResource = Handle<GraphicsBuffer>.Invalid;
+
+        _size = 0;
+    }
+}
+
+public struct Material : IResourceReleasable
+{
+    private struct PipelineOverride
+    {
+        public Key64<ShaderPass> shaderPass;
+        public PipelineState options;
+    }
+
+    private Identifier<Shader> _shader;
+    private UnsafeArray<PipelineOverride> _passPipelineOverride;
+    private bool _isDirty;
+
+    internal CBufferCache _cBufferCache;
+    internal LocalKeywordSet _keywordMask;
+
+    public readonly Identifier<Shader> Shader => _shader;
+    public readonly bool IsDirty => _isDirty;
+
+    public int ActivePassIndex
+    {
+        get; set;
+    }
+
+    public Error SetShader(Identifier<Shader> shaderId, IResourceAllocator allocator, IResourceDatabase database)
+    {
+        if (!shaderId.IsValid)
+        {
+            return Error.InvalidArgument;
+        }
+
+        _cBufferCache.ReleaseResource(database);
+        _shader = shaderId;
+
+        var r = database.GetShaderReference(shaderId);
+        if (r.IsFailure)
+        {
+            return r.Error;
+        }
+
+        ref readonly var shader = ref r.Value;
+        if (_passPipelineOverride.Count < shader.PassCount)
+        {
+            if (!_passPipelineOverride.IsCreated)
+            {
+                _passPipelineOverride = new UnsafeArray<PipelineOverride>(shader.PassCount, Allocator.Persistent);
+            }
+            else
+            {
+                _passPipelineOverride.Resize(shader.PassCount);
+            }
+        }
+
+        _keywordMask.Clear();
+        for (var i = 0; i < shader.PassCount; i++)
+        {
+            ref var pass = ref shader.GetPassReference(i);
+            _passPipelineOverride[i] = new PipelineOverride
+            {
+                shaderPass = pass.Key,
+                options = pass.DeafaultState,
+            };
+        }
+
+        if (shader.CBufferSize != 0)
+        {
+            var desc = new BufferDesc
+            {
+                Size = shader.CBufferSize,
+                Usage = BufferUsage.Raw | BufferUsage.ShaderResource,
+                MemoryType = ResourceMemoryType.Default,
+            };
+
+            var buffer = allocator.CreateBuffer(ref desc, "MaterialCBuffer");
+            _cBufferCache = new CBufferCache(buffer, shader.CBufferSize);
+        }
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly unsafe Result<T, Error> GetPropertyCache<T>()
+        where T : unmanaged
+    {
+        if (sizeof(T) != _cBufferCache.Size)
+        {
+            return Error.InvalidArgument;
+        }
+
+        return *(T*)_cBufferCache.CpuData.GetUnsafePtr();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ReadOnlySpan<byte> GetRawPropertyCache()
+    {
+        if (_cBufferCache.Size == 0)
+        {
+            return [];
+        }
+
+        return _cBufferCache.CpuData.AsSpan(0, (int)_cBufferCache.Size);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public unsafe Error SetPropertyCache<T>(scoped ref readonly T data)
+        where T : unmanaged
+    {
+        if (sizeof(T) != _cBufferCache.Size)
+        {
+            return Error.InvalidArgument;
+        }
+
+        var dataSpan = MemoryMarshal.AsBytes(new ReadOnlySpan<T>(in data));
+        var cacheSpan = _cBufferCache.CpuData.AsSpan();
+        if (cacheSpan.SequenceEqual(dataSpan))
+        {
+            return Error.None;
+        }
+
+        dataSpan.CopyTo(cacheSpan);
+        _isDirty = true;
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Error SetRawPropertyCache(ReadOnlySpan<byte> data)
+    {
+        if (data.Length != _cBufferCache.Size)
+        {
+            return Error.InvalidArgument;
+        }
+
+        var cacheSpan = _cBufferCache.CpuData.AsSpan();
+        if (cacheSpan.SequenceEqual(data))
+        {
+            return Error.None;
+        }
+
+        data.CopyTo(cacheSpan);
+        _isDirty = true;
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly PipelineState GetPassPipelineOverride(int passIndex)
+    {
+        return _passPipelineOverride[passIndex].options;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void SetPassPipelineOverride(int passIndex, scoped ref readonly PipelineState options)
+    {
+        ref var pipelineOverride = ref _passPipelineOverride[passIndex];
+        pipelineOverride.options = options;
+        _isDirty = true;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Error SetKeyword(IResourceDatabase resourceDatabase, int keywordId, bool enabled)
+    {
+        var r = resourceDatabase.GetShaderReference(_shader);
+        if (r.IsFailure)
+        {
+            return r.Error;
+        }
+
+        ref readonly var shader = ref r.Value;
+        var localIndex = shader.GetLocalKeywordIndex(keywordId);
+        if (localIndex == -1)
+        {
+            return Error.NotFound;
+        }
+
+        _keywordMask.SetKeyword(localIndex, enabled);
+        _isDirty = true;
+
+        return Error.None;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly bool IsKeywordEnabled(IResourceDatabase resourceDatabase, int keywordId)
+    {
+        var r = resourceDatabase.GetShaderReference(_shader);
+        if (r.IsFailure)
+        {
+            return false;
+        }
+
+        ref readonly var shader = ref r.Value;
+        var localIndex = shader.GetLocalKeywordIndex(keywordId);
+        if (localIndex == -1)
+        {
+            return false;
+        }
+
+        return _keywordMask.IsKeywordEnabled(localIndex);
+    }
+
+    public readonly void UploadData(ICommandBuffer cmd, IResourceDatabase resourceDatabase)
+    {
+        if (!_isDirty)
+        {
+            return;
+        }
+
+        var cbufferResource = _cBufferCache.GpuResource.AsResource();
+        var r = resourceDatabase.GetResourceBarrierData(cbufferResource);
+        if (r.IsFailure)
+        {
+            return;
+        }
+
+        var barrierData = r.Value;
+        var desc = BarrierDesc.Buffer(
+            cbufferResource,
+            barrierData.sync,
+            BarrierSync.Copy,
+            barrierData.access,
+            BarrierAccess.CopyDest);
+
+        cmd.ResourceBarrier(desc);
+        cmd.UploadBuffer(_cBufferCache.GpuResource, _cBufferCache.CpuData.AsSpan());
+
+        desc = BarrierDesc.Buffer(
+            cbufferResource,
+            BarrierSync.Copy,
+            BarrierSync.AllShading,
+            BarrierAccess.CopyDest,
+            BarrierAccess.ShaderResource);
+
+        cmd.ResourceBarrier(desc);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    void IResourceReleasable.ReleaseResource(IResourceDatabase database)
+    {
+        _cBufferCache.ReleaseResource(database);
+        _passPipelineOverride.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/Core/Mesh.cs

@@ -0,0 +1,171 @@
+using Ghost.Core;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.Utilities;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using Misaki.HighPerformance.Mathematics;
+using Misaki.HighPerformance.Mathematics.Geometry;
+
+namespace Ghost.Graphics.Core;
+
+public struct Mesh : IResourceReleasable
+{
+    private UnsafeList<Vertex> _vertices;
+    private UnsafeList<uint> _indices;
+
+    internal bool IsMeshDataDirty
+    {
+        get; private set;
+    }
+
+    /// <summary>
+    /// Gets or sets the collection of vertices that define the geometry.
+    /// </summary>
+    public UnsafeList<Vertex> Vertices
+    {
+        readonly get => _vertices;
+        set
+        {
+            _vertices = value;
+            VertexCount = value.Count;
+            IsMeshDataDirty = true;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the collection of indices that define the order of vertices.
+    /// </summary>
+    public UnsafeList<uint> Indices
+    {
+        readonly get => _indices;
+        set
+        {
+            _indices = value;
+            IndexCount = value.Count;
+            IsMeshDataDirty = true;
+        }
+    }
+
+    /// <summary>
+    /// Get the number of vertices in the mesh.
+    /// </summary>
+    public int VertexCount
+    {
+        get; private set;
+    }
+
+    /// <summary>
+    /// Get the number of indices in the mesh.
+    /// </summary>
+    public int IndexCount
+    {
+        get; private set;
+    }
+
+    /// <summary>
+    /// Gets or sets the axis-aligned bounding box (AABB) of the mesh.
+    /// </summary>
+    public AABB BoundingBox
+    {
+        get; set;
+    }
+
+    /// <summary>
+    /// Gets the handle to the vertex buffer on the GPU.
+    /// </summary>
+    public Handle<GraphicsBuffer> VertexBuffer
+    {
+        get; internal set;
+    }
+
+    /// <summary>
+    /// Gets the handle to the index buffer on the GPU.
+    /// </summary>
+    public Handle<GraphicsBuffer> IndexBuffer
+    {
+        get; internal set;
+    }
+
+    /// <summary>
+    /// Gets the handle to the mesh data buffer on the GPU.
+    /// </summary>
+    public Handle<GraphicsBuffer> ObjectDataBuffer
+    {
+        get; internal set;
+    }
+
+    internal Mesh(ReadOnlySpan<Vertex> vertices, ReadOnlySpan<uint> indices, Handle<GraphicsBuffer> vertexBuffer, Handle<GraphicsBuffer> indexBuffer)
+    {
+        Vertices = new UnsafeList<Vertex>(vertices.Length, Allocator.Persistent);
+        Indices = new UnsafeList<uint>(indices.Length, Allocator.Persistent);
+        Vertices.CopyFrom(vertices);
+        Indices.CopyFrom(indices);
+        VertexBuffer = vertexBuffer;
+        IndexBuffer = indexBuffer;
+
+        this.ComputeBounds();
+    }
+
+    public readonly void ReleaseCpuResources()
+    {
+        _vertices.Dispose();
+        _indices.Dispose();
+    }
+
+    readonly void IResourceReleasable.ReleaseResource(IResourceDatabase database)
+    {
+        ReleaseCpuResources();
+
+        database.ReleaseResource(VertexBuffer.AsResource());
+        database.ReleaseResource(IndexBuffer.AsResource());
+        database.ReleaseResource(ObjectDataBuffer.AsResource());
+    }
+}
+
+public static class MeshExtension
+{
+    /// <summary>
+    /// Computes the bounding box of the mesh based on its vertices.
+    /// </summary>
+    public static void ComputeBounds(ref this Mesh mesh)
+    {
+        if (mesh.Vertices.Count == 0)
+        {
+            return;
+        }
+
+        var min = new float3(float.MaxValue);
+        var max = new float3(float.MinValue);
+        foreach (var vertex in mesh.Vertices)
+        {
+            var pos = vertex.position.xyz;
+            min = math.min(min, pos);
+            max = math.max(max, pos);
+        }
+
+        mesh.BoundingBox = new AABB(min, max);
+    }
+
+    /// <summary>
+    /// Auto-compute smooth per-vertex normals.
+    /// </summary>
+    /// <remarks>
+    /// Call this method before vertices and indices are valid.
+    /// </remarks>
+    public static void ComputeNormal(ref this Mesh mesh)
+    {
+        MeshBuilder.ComputeNormal(mesh.Vertices, mesh.Indices);
+    }
+
+    /// <summary>
+    /// Auto-compute per-vertex tangents.
+    /// </summary>
+    /// <remarks>
+    /// Call this method before vertices, normals, and UVs are valid.
+    /// </remarks>
+    public static void ComputeTangents(ref this Mesh mesh)
+    {
+        MeshBuilder.ComputeTangents(mesh.Vertices, mesh.Indices);
+    }
+}

src/Runtime/Ghost.Graphics/Core/RenderOutput.cs

@@ -0,0 +1,95 @@
+using Ghost.Core;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RHI;
+
+namespace Ghost.Graphics.Core;
+
+internal class SwapChainRenderOutput : IRenderOutput
+{
+    private readonly ISwapChain _swapChain;
+
+    public ViewportDesc Viewport
+    {
+        get; set;
+    }
+
+    public RectDesc Scissor
+    {
+        get; set;
+    }
+
+    public SwapChainRenderOutput(ISwapChain swapChain)
+    {
+        _swapChain = swapChain;
+
+        Viewport = new ViewportDesc { Width = swapChain.Width, Height = swapChain.Height, MinDepth = 0, MaxDepth = 1 };
+        Scissor = new RectDesc { Right = swapChain.Width, Bottom = swapChain.Height };
+    }
+
+    public Handle<Texture> GetRenderTarget()
+    {
+        return _swapChain.GetCurrentBackBuffer();
+    }
+
+    public void BeginRender(ICommandBuffer cmd)
+    {
+        var barrierDesc = BarrierDesc.Texture(_swapChain.GetCurrentBackBuffer().AsResource(),
+            BarrierSync.None, BarrierSync.RenderTarget,
+            BarrierAccess.NoAccess, BarrierAccess.RenderTarget,
+            BarrierLayout.Present, BarrierLayout.RenderTarget);
+
+        cmd.ResourceBarrier(barrierDesc);
+    }
+
+    public void EndRender(ICommandBuffer cmd)
+    {
+        var barrierDesc = BarrierDesc.Texture(_swapChain.GetCurrentBackBuffer().AsResource(),
+            BarrierSync.RenderTarget, BarrierSync.None,
+            BarrierAccess.RenderTarget, BarrierAccess.NoAccess,
+            BarrierLayout.RenderTarget, BarrierLayout.Present);
+
+        cmd.ResourceBarrier(barrierDesc);
+    }
+
+    public void Present()
+    {
+        _swapChain.Present();
+    }
+}
+
+internal class TextureRenderOutput : IRenderOutput
+{
+    private readonly Handle<Texture> _texture;
+
+    public ViewportDesc Viewport
+    {
+        get; set;
+    }
+
+    public RectDesc Scissor
+    {
+        get; set;
+    }
+
+    public TextureRenderOutput(Handle<Texture> texture)
+    {
+        _texture = texture;
+    }
+
+    public Handle<Texture> GetRenderTarget()
+    {
+        return _texture;
+    }
+
+    public void BeginRender(ICommandBuffer cmd)
+    {
+    }
+
+    public void EndRender(ICommandBuffer cmd)
+    {
+    }
+
+    public void Present()
+    {
+    }
+}

src/Runtime/Ghost.Graphics/Core/RenderingContext.cs

@@ -0,0 +1,219 @@
+using Ghost.Core;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using Misaki.HighPerformance.Mathematics;
+
+namespace Ghost.Graphics.Core;
+
+public readonly unsafe ref struct RenderingContext
+{
+    private readonly IGraphicsEngine _engine;
+    private readonly ICommandBuffer _directCmd;
+
+    public ICommandBuffer DirectCommandBuffer => _directCmd;
+
+    public IShaderCompiler ShaderCompiler => _engine.ShaderCompiler;
+    public IResourceAllocator ResourceAllocator => _engine.ResourceAllocator;
+    public IResourceDatabase ResourceDatabase => _engine.ResourceDatabase;
+    public IPipelineLibrary PipelineLibrary => _engine.PipelineLibrary;
+
+    internal RenderingContext(IGraphicsEngine engine, ICommandBuffer directCmd)
+    {
+        _engine = engine;
+        _directCmd = directCmd;
+    }
+
+    public ICommandBuffer CrearteCommandBuffer(CommandBufferType type)
+    {
+        return _engine.CreateCommandBuffer(type);
+    }
+
+    // TODO: ExecuteCommandBufferAsync with fencene.Device.GraphicsQueue.Submit(commandBuffer);
+    public void ExecuteCommandBuffer(ICommandBuffer commandBuffer)
+    {
+        var queue = commandBuffer.Type switch
+        {
+            CommandBufferType.Graphics => _engine.Device.GraphicsQueue,
+            CommandBufferType.Compute => _engine.Device.ComputeQueue,
+            CommandBufferType.Copy => _engine.Device.CopyQueue,
+            _ => throw new InvalidOperationException("Unknown command buffer type."),
+        };
+
+        queue.Submit(commandBuffer);
+        queue.WaitIdle();
+    }
+
+    private void TransitionBarrier(Handle<GPUResource> resource, bool isTexture, BarrierLayout newLayout, BarrierAccess newAccess, BarrierSync newSync)
+    {
+        var r = ResourceDatabase.GetResourceBarrierData(resource);
+        if (r.IsFailure)
+        {
+            return;
+        }
+
+        var data = r.Value;
+        if (data.layout == newLayout && data.access == newAccess && data.sync == newSync)
+        {
+            return;
+        }
+
+        BarrierDesc desc;
+        if (isTexture)
+        {
+            desc = BarrierDesc.Texture(
+            resource,
+            data.sync, newSync,
+            data.access, newAccess,
+            data.layout, newLayout);
+        }
+        else
+        {
+            desc = BarrierDesc.Buffer(
+            resource,
+            data.sync, newSync,
+            data.access, newAccess);
+        }
+
+        _directCmd.ResourceBarrier(new ReadOnlySpan<BarrierDesc>(in desc));
+        ResourceDatabase.SetResourceBarrierData(resource, new ResourceBarrierData(newLayout, newAccess, newSync));
+    }
+
+    public Handle<Mesh> CreateMesh(UnsafeList<Vertex> vertices, UnsafeList<uint> indices, bool staticMesh)
+    {
+        var mesh = ResourceAllocator.CreateMesh(vertices, indices);
+        var r = ResourceDatabase.GetMeshReference(mesh);
+        if (r.IsFailure)
+        {
+            return mesh;
+        }
+
+        ref readonly var meshData = ref r.Value;
+        var vertexHandle = meshData.VertexBuffer.AsResource();
+        var indexHandle = meshData.IndexBuffer.AsResource();
+
+        TransitionBarrier(vertexHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
+        TransitionBarrier(indexHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
+
+        _directCmd.UploadBuffer(meshData.VertexBuffer, meshData.Vertices.AsSpan());
+        _directCmd.UploadBuffer(meshData.IndexBuffer, meshData.Indices.AsSpan());
+
+        if (staticMesh)
+        {
+            meshData.ReleaseCpuResources();
+            TransitionBarrier(vertexHandle, false, BarrierLayout.Undefined, BarrierAccess.ShaderResource, BarrierSync.VertexShading);
+            TransitionBarrier(indexHandle, false, BarrierLayout.Undefined, BarrierAccess.IndexBuffer, BarrierSync.IndexInput);
+        }
+
+        return mesh;
+    }
+
+    public Handle<Mesh> CreateMesh(ReadOnlySpan<Vertex> vertices, ReadOnlySpan<uint> indices, bool staticMesh)
+    {
+        var vertexList = new UnsafeList<Vertex>(vertices.Length, Allocator.Persistent);
+        var indexList = new UnsafeList<uint>(indices.Length, Allocator.Persistent);
+
+        vertexList.CopyFrom(vertices);
+        indexList.CopyFrom(indices);
+
+        return CreateMesh(vertexList, indexList, staticMesh);
+    }
+
+    // TODO: Make one memory pool for upload.
+
+    /// <summary>
+    /// Uploads the mesh data to the GPU.
+    /// </summary>
+    /// <param name="mesh">The handle point to the mesh buffer</param>
+    /// <param name="markMeshStatic">Whether to mark the mesh as static. If it's true, the cpu buffer of the mesh will not be avaliable any more</param>
+    public void UploadMesh(Handle<Mesh> mesh, bool markMeshStatic)
+    {
+        var r = ResourceDatabase.GetMeshReference(mesh);
+        if (r.IsFailure)
+        {
+            return;
+        }
+
+        ref readonly var meshRef = ref r.Value;
+        var vertexHandle = meshRef.VertexBuffer.AsResource();
+        var indexHandle = meshRef.IndexBuffer.AsResource();
+
+        TransitionBarrier(vertexHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
+        TransitionBarrier(indexHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
+
+        _directCmd.UploadBuffer(meshRef.VertexBuffer, meshRef.Vertices.AsSpan());
+        _directCmd.UploadBuffer(meshRef.IndexBuffer, meshRef.Indices.AsSpan());
+
+        TransitionBarrier(vertexHandle, false, BarrierLayout.Undefined, BarrierAccess.ShaderResource, BarrierSync.VertexShading);
+        TransitionBarrier(indexHandle, false, BarrierLayout.Undefined, BarrierAccess.IndexBuffer, BarrierSync.IndexInput);
+
+        if (markMeshStatic)
+        {
+            meshRef.ReleaseCpuResources();
+        }
+    }
+
+    public void UpdateObjectData(Handle<Mesh> mesh, float4x4 localToWorld)
+    {
+        var r = ResourceDatabase.GetMeshReference(mesh);
+        if (r.IsFailure)
+        {
+            return;
+        }
+
+        ref readonly var meshData = ref r.Value;
+        var data = new PerObjectData
+        {
+            localToWorld = localToWorld,
+            worldBoundsMin = meshData.BoundingBox.Min,
+            worldBoundsMax = meshData.BoundingBox.Max,
+            vertexBuffer = _engine.ResourceDatabase.GetBindlessIndex(meshData.VertexBuffer.AsResource()),
+            indexBuffer = _engine.ResourceDatabase.GetBindlessIndex(meshData.IndexBuffer.AsResource()),
+        };
+
+        var bufferHandle = meshData.ObjectDataBuffer.AsResource();
+
+        TransitionBarrier(bufferHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
+        _directCmd.UploadBuffer(meshData.ObjectDataBuffer, data);
+        TransitionBarrier(bufferHandle, false, BarrierLayout.Undefined, BarrierAccess.ShaderResource, BarrierSync.PixelShading | BarrierSync.NonPixelShading);
+    }
+
+    public Handle<Texture> CreateTexture<T>(ref readonly TextureDesc desc, ReadOnlySpan<T> data, string name)
+        where T : unmanaged
+    {
+        var handle = ResourceAllocator.CreateTexture(in desc, name);
+        UploadTexture(handle, data);
+
+        return handle;
+    }
+
+    public void UploadTexture<T>(Handle<Texture> texture, ReadOnlySpan<T> data)
+        where T : unmanaged
+    {
+        var desc = ResourceDatabase.GetResourceDescription(texture.AsResource()).GetValueOrThrow();
+        
+        //var size = ResourceAllocator.GetSizeInfo(desc).Size;
+        //if ((ulong)(data.Length * sizeof(T)) != ResourceAllocator.GetSizeInfo(desc).Size)
+        //{
+        //    throw new ArgumentException("Data size does not match texture size.");
+        //}
+
+        desc.TextureDescription.Format.GetSurfaceInfo(desc.TextureDescription.Width, desc.TextureDescription.Height, out var rowPitch, out var slicePitch, out _);
+
+        TransitionBarrier(texture.AsResource(), true, BarrierLayout.CopyDest, BarrierAccess.CopyDest, BarrierSync.Copy);
+
+        fixed (T* pData = data)
+        {
+            var subresourceData = new SubResourceData
+            {
+                pData = pData,
+                rowPitch = rowPitch,
+                slicePitch = slicePitch
+            };
+
+            _directCmd.UploadTexture(texture, subresourceData);
+        }
+    }
+}

src/Runtime/Ghost.Graphics/Core/ResourceHandle.cs

@@ -0,0 +1,32 @@
+using Ghost.Core;
+
+namespace Ghost.Graphics.Core;
+
+public readonly struct GPUResource;
+public readonly struct Texture;
+public readonly struct GraphicsBuffer;
+
+public readonly struct Sampler;
+
+public static class ResourceHandleExtensions
+{
+    public static Handle<GPUResource> AsResource(this Handle<Texture> texture)
+    {
+        return new Handle<GPUResource>(texture.ID, texture.Generation);
+    }
+
+    public static Handle<GPUResource> AsResource(this Handle<GraphicsBuffer> buffer)
+    {
+        return new Handle<GPUResource>(buffer.ID, buffer.Generation);
+    }
+
+    internal static Handle<Texture> AsTexture(this Handle<GPUResource> resource)
+    {
+        return new Handle<Texture>(resource.ID, resource.Generation);
+    }
+
+    internal static Handle<GraphicsBuffer> AsGraphicsBuffer(this Handle<GPUResource> resource)
+    {
+        return new Handle<GraphicsBuffer>(resource.ID, resource.Generation);
+    }
+}

src/Runtime/Ghost.Graphics/Core/RootSignatureLayout.cs

@@ -0,0 +1,75 @@
+using Misaki.HighPerformance.Mathematics;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Graphics.Core;
+
+/// <summary>
+/// The layout of the root signature is:
+/// <list space="bullet">
+/// <item>
+/// Global buffer (b0)
+/// </item>
+/// <item>
+/// Per-view buffer (b1)
+/// </item>
+/// <item>
+/// Per-object buffer (b2)
+/// </item>
+/// <item>
+/// Per-material buffer (b3)
+/// </item>
+/// <item>
+/// Descriptor table for bindless textures (t0)
+/// </item>
+/// <item>
+/// Descriptor table for bindless samplers (s0)
+/// </item>
+/// </list>
+/// </summary>
+public static class RootSignatureLayout
+{
+    // public const int GLOBAL_BUFFER_SLOT = 0;
+    // public const int PER_VIEW_BUFFER_SLOT = 1;
+    // public const int PER_OBJECT_BUFFER_SLOT = 2;
+    // public const int PER_MATERIAL_BUFFER_SLOT = 3;
+
+    // public const int TEXTURE_HEAP_SLOT = 0;
+    // public const int SAMPLER_HEAP_SLOT = 0;
+
+    public const int PUSH_CONSTANT_SLOT = 0;
+
+    public const int ROOT_PARAMETER_COUNT = 1;
+}
+
+[StructLayout(LayoutKind.Sequential, Size = 16)]
+public struct PushConstantsData
+{
+    public uint globalIndex;
+    public uint viewIndex;
+    public uint objectIndex;
+    public uint materialIndex;
+}
+
+// The size should be 176 bytes (16-byte aligned)
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public struct PerViewData
+{
+    public float4x4 viewMatrix;
+    public float4x4 projectionMatrix;
+    public float3 cameraPosition;
+    public float nearClip;
+    public float3 cameraDirection;
+    public float farClip;
+    public float4 screenSize; // xy: size, zw: 1/size
+};
+
+// The size should be 96 bytes (16-byte aligned)
+[StructLayout(LayoutKind.Sequential, Pack = 1)]
+public struct PerObjectData
+{
+    public float4x4 localToWorld;
+    public float3 worldBoundsMin;
+    public uint vertexBuffer;
+    public float3 worldBoundsMax;
+    public uint indexBuffer;
+};

src/Runtime/Ghost.Graphics/Core/Shader.cs

@@ -0,0 +1,210 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Graphics.Core;
+
+public readonly struct ShaderPass
+{
+    public Key64<ShaderPass> Key
+    {
+        get; init;
+    }
+
+    public PipelineState DeafaultState
+    {
+        get; init;
+    }
+
+    public LocalKeywordSet KeywordIDs
+    {
+        get; init;
+    }
+}
+
+public struct ShaderProperty;
+
+public partial struct Shader
+{
+    private static readonly Dictionary<string, int> s_passNameToID = new Dictionary<string, int>();
+    private static int s_nextPassID = 0;
+
+    private static readonly Dictionary<string, int> s_propertyNameToID = new Dictionary<string, int>();
+    private static int s_nextPropertyID = 0;
+
+    private static readonly Dictionary<string, int> s_keywordNameToID = new Dictionary<string, int>();
+    private static readonly Dictionary<int, string> s_keywordIDToName = new Dictionary<int, string>();
+    private static int s_nextKeywordID = 0;
+
+    public static Identifier<ShaderPass> GetPassID(string passName)
+    {
+        ref var id = ref CollectionsMarshal.GetValueRefOrAddDefault(s_passNameToID, passName, out var exists);
+        if (!exists)
+        {
+            id = s_nextPassID++;
+        }
+
+        return id;
+    }
+
+    public static Identifier<ShaderProperty> GetPropertyID(string propertyName)
+    {
+        ref var id = ref CollectionsMarshal.GetValueRefOrAddDefault(s_propertyNameToID, propertyName, out var exists);
+        if (!exists)
+        {
+            id = s_nextPropertyID++;
+        }
+
+        return id;
+    }
+
+    public static int GetKeywordID(string keywordName)
+    {
+        ref var id = ref CollectionsMarshal.GetValueRefOrAddDefault(s_keywordNameToID, keywordName, out var exists);
+        if (!exists)
+        {
+            id = s_nextKeywordID++;
+        }
+
+        s_keywordIDToName[id] = keywordName;
+        return id;
+    }
+
+    public static string? GetKeywordName(int keywordID)
+    {
+        if (s_keywordIDToName.TryGetValue(keywordID, out var name))
+        {
+            return name;
+        }
+
+        return null;
+    }
+
+    // TODO: Global keywords
+}
+
+/// <summary>
+/// A representation of a GPU shader, including all the passes it contains.
+/// </summary>
+public partial struct Shader : IResourceReleasable
+{
+    private readonly uint _cbufferSize;
+    private UnsafeArray<ShaderPass> _shaderPasses;
+    private UnsafeHashMap<int, int> _passIDToLocal;
+    private UnsafeHashMap<int, int> _keywordIDToLocal;
+
+    // TODO: Tag to pass index for fast lookup.
+    // We can use a int array since the number and index of tags are fixed at compile time.
+
+    public readonly int PassCount => _shaderPasses.Count;
+    public readonly uint CBufferSize => _cbufferSize;
+
+    internal Shader(ShaderDescriptor descriptor)
+    {
+        _cbufferSize = (uint)descriptor.cbufferSize;
+        _shaderPasses = new UnsafeArray<ShaderPass>(descriptor.passes.Length, Allocator.Persistent);
+        _passIDToLocal = new UnsafeHashMap<int, int>(descriptor.passes.Length, Allocator.Persistent);
+        _keywordIDToLocal = new UnsafeHashMap<int, int>(32, Allocator.Persistent);
+
+        for (var i = 0; i < descriptor.passes.Length; i++)
+        {
+            var pass = descriptor.passes[i];
+            var passKey = RHIUtility.CreateShaderPassKey(pass.identifier);
+            var keywords = default(LocalKeywordSet);
+
+            if (pass.keywords.Length > 0)
+            {
+                var localKeywordIndex = 0;
+
+                for (var j = 0; j < pass.keywords.Length; j++)
+                {
+                    var group = pass.keywords[j];
+                    if (group.keywords == null)
+                    {
+                        continue;
+                    }
+
+                    if (group.space == KeywordSpace.Local)
+                    {
+                        foreach (var kw in group.keywords)
+                        {
+                            var kwID = GetKeywordID(kw);
+                            var idx = localKeywordIndex++;
+
+                            keywords.SetKeyword(idx, true);
+                            _keywordIDToLocal.TryAdd(kwID, idx);
+                        }
+                    }
+
+                    // TODO: Global keywords
+                }
+            }
+
+            _shaderPasses[i] = new ShaderPass
+            {
+                Key = passKey,
+                DeafaultState = pass.localPipeline,
+                KeywordIDs = keywords,
+            };
+
+            _passIDToLocal[GetPassID(pass.name)] = (ushort)i;
+        }
+    }
+
+    internal readonly int GetLocalKeywordIndex(int globalKeywordID)
+    {
+        if (_keywordIDToLocal.TryGetValue(globalKeywordID, out var localIndex))
+        {
+            return localIndex;
+        }
+
+        return -1;
+    }
+
+    public readonly int GetPassIndex(Identifier<ShaderPass> passID)
+    {
+        if (_passIDToLocal.TryGetValue(passID.Value, out var index))
+        {
+            return index;
+        }
+
+        return -1;
+    }
+
+    public readonly int GetPassIndex(string passName)
+    {
+        if (_passIDToLocal.TryGetValue(GetPassID(passName), out var index))
+        {
+            return index;
+        }
+
+        return -1;
+    }
+
+    public readonly ref ShaderPass GetPassReference(int index)
+    {
+        return ref _shaderPasses[index];
+    }
+
+    public readonly Result<ShaderPass, Error> TryGetPass(Identifier<ShaderPass> passID, out int passIndex)
+    {
+        if (_passIDToLocal.TryGetValue(passID.Value, out var index))
+        {
+            passIndex = -1;
+            return Error.NotFound;
+        }
+
+        passIndex = index;
+        return _shaderPasses[index];
+    }
+
+    void IResourceReleasable.ReleaseResource(IResourceDatabase database)
+    {
+        _keywordIDToLocal.Dispose();
+        _shaderPasses.Dispose();
+        _passIDToLocal.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12CommandAllocator.cs

@@ -0,0 +1,34 @@
+using Ghost.Core.Utilities;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using TerraFX.Interop.DirectX;
+
+namespace Ghost.Graphics.D3D12;
+
+internal unsafe class D3D12CommandAllocator : ICommandAllocator
+{
+    private UniquePtr<ID3D12CommandAllocator> _allocator;
+
+    public SharedPtr<ID3D12CommandAllocator> NativeAllocator => _allocator.Share();
+
+    public D3D12CommandAllocator(D3D12RenderDevice device, CommandBufferType type)
+    {
+        ID3D12CommandAllocator* pAllocator = default;
+        var commandListType = D3D12Utility.ToCommandListType(type);
+
+        device.NativeDevice.Get()->CreateCommandAllocator(commandListType, __uuidof(pAllocator), (void**)&pAllocator);
+
+        _allocator.Attach(pAllocator);
+    }
+
+    public void Reset()
+    {
+        _allocator.Get()->Reset();
+    }
+
+    public void Dispose()
+    {
+        _allocator.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12CommandBuffer.cs

@@ -0,0 +1,999 @@
+using Ghost.Core;
+using Ghost.Core.Utilities;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using System.Runtime.CompilerServices;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Aliases.D3D_Alias;
+using static TerraFX.Aliases.D3D12_Alias;
+using static TerraFX.Aliases.DXGI_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+internal unsafe class D3D12CommandBuffer : ICommandBuffer
+{
+    private UniquePtr<ID3D12GraphicsCommandList10> _commandList;
+
+    private readonly D3D12PipelineLibrary _pipelineLibrary;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+    private readonly D3D12ResourceAllocator _resourceAllocator;
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+    private readonly CommandBufferType _type;
+
+#if !DEBUG
+    private CommandError _lastError;
+#endif
+    private ushort _commandCount;
+    private bool _isRecording;
+    private bool _disposed;
+
+    public SharedPtr<ID3D12GraphicsCommandList10> NativeCommandList => _commandList.Get();
+
+    public CommandBufferType Type => _type;
+    public bool IsEmpty => _commandCount == 0;
+
+    public string Name
+    {
+        get => field;
+        set
+        {
+            if (field == value)
+            {
+                return;
+            }
+
+            field = value;
+            _commandList.Get()->SetName(value);
+        }
+    } = string.Empty;
+
+    public D3D12CommandBuffer(
+        D3D12RenderDevice device,
+        D3D12PipelineLibrary stateController,
+        D3D12ResourceDatabase resourceDatabase,
+        D3D12ResourceAllocator resourceAllocator,
+        D3D12DescriptorAllocator descriptorAllocator,
+        CommandBufferType type)
+    {
+        _type = type;
+
+        ID3D12GraphicsCommandList10* pCommandList = default;
+        var commandListType = D3D12Utility.ToCommandListType(type);
+
+        device.NativeDevice.Get()->CreateCommandList1(0u, commandListType, D3D12_COMMAND_LIST_FLAG_NONE, __uuidof(pCommandList), (void**)&pCommandList);
+
+        _commandList.Attach(pCommandList);
+
+        _pipelineLibrary = stateController;
+        _resourceDatabase = resourceDatabase;
+        _resourceAllocator = resourceAllocator;
+        _descriptorAllocator = descriptorAllocator;
+
+        _isRecording = false;
+    }
+
+    ~D3D12CommandBuffer()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ThrowIfDisposed()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ThrowIfRecording()
+    {
+        if (_isRecording)
+        {
+            throw new InvalidOperationException("Command buffer is already recording");
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ThrowIfNotRecording()
+    {
+        if (!_isRecording)
+        {
+            throw new InvalidOperationException("Command buffer is not recording");
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void IncrementCommandCount()
+    {
+        _commandCount++;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#if DEBUG
+    [System.Diagnostics.CodeAnalysis.DoesNotReturn]
+    private static void RecordError(string cmdName, Error status)
+#else
+    private void RecordError(string cmdName, Error status)
+#endif
+    {
+#if DEBUG
+        throw new InvalidOperationException($"Error at {cmdName} with {status}");
+#else
+
+        _lastError = new CommandError
+        {
+            CommandName = cmdName,
+            CommandIndex = _commandCount,
+            Status = status
+        };
+#endif
+    }
+
+    public void Begin(ICommandAllocator allocator)
+    {
+        ThrowIfDisposed();
+        ThrowIfRecording();
+
+        if (allocator is not D3D12CommandAllocator d3d12Allocator)
+        {
+            throw new ArgumentException("Invalid command allocator type", nameof(allocator));
+        }
+
+        ThrowIfFailed(_commandList.Get()->Reset(d3d12Allocator.NativeAllocator, null));
+
+        if (Type == CommandBufferType.Graphics || Type == CommandBufferType.Compute)
+        {
+            // Set descriptor heaps for bindless resources and samplers
+
+            var heaps = stackalloc ID3D12DescriptorHeap*[2];
+            heaps[0] = _descriptorAllocator.GetCbvSrvUavHeap(); // Bindless resource Heap
+            heaps[1] = _descriptorAllocator.GetSamplerHeap();   // Bindless sampler Heap
+            _commandList.Get()->SetDescriptorHeaps(2, heaps);
+        }
+
+        _commandCount = 0;
+        _isRecording = true;
+    }
+
+    public Result End()
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+
+        _commandList.Get()->Close();
+        _isRecording = false;
+
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return Result.Failure($"Command buffer ended with errors at {_lastError.CommandIndex}, command '{_lastError.CommandName}': {_lastError.Status}");
+        }
+#endif
+
+        return Result.Success();
+    }
+
+    public void SetScissorRect(RectDesc rect)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var d3d12Rect = new RECT((int)rect.Left, (int)rect.Top, (int)rect.Right, (int)rect.Bottom);
+        _commandList.Get()->RSSetScissorRects(1, &d3d12Rect);
+    }
+
+    public void ResourceBarrier(params ReadOnlySpan<BarrierDesc> barrierDescs)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        if (barrierDescs.IsEmpty)
+        {
+            return;
+        }
+
+        var globalCount = 0;
+        var bufferCount = 0;
+        var textureCount = 0;
+
+        for (var i = 0; i < barrierDescs.Length; i++)
+        {
+            switch (barrierDescs[i].Type)
+            {
+                case BarrierType.Global: globalCount++; break;
+                case BarrierType.Buffer: bufferCount++; break;
+                case BarrierType.Texture: textureCount++; break;
+            }
+        }
+
+        var pGlobalBarriers = stackalloc D3D12_GLOBAL_BARRIER[globalCount];
+        var pBufferBarriers = stackalloc D3D12_BUFFER_BARRIER[bufferCount];
+        var pTextureBarriers = stackalloc D3D12_TEXTURE_BARRIER[textureCount];
+
+        var globalIndex = 0;
+        var bufferIndex = 0;
+        var textureIndex = 0;
+
+        for (var i = 0; i < barrierDescs.Length; i++)
+        {
+            var desc = barrierDescs[i];
+            switch (desc.Type)
+            {
+                case BarrierType.Global:
+                    pGlobalBarriers[globalIndex++] = new D3D12_GLOBAL_BARRIER
+                    {
+                        SyncBefore = (D3D12_BARRIER_SYNC)desc.SyncBefore,
+                        SyncAfter = (D3D12_BARRIER_SYNC)desc.SyncAfter,
+                        AccessBefore = (D3D12_BARRIER_ACCESS)desc.AccessBefore,
+                        AccessAfter = (D3D12_BARRIER_ACCESS)desc.AccessAfter
+                    };
+                    break;
+                case BarrierType.Buffer:
+                {
+                    var r = _resourceDatabase.GetResourceRecord(desc.Resource);
+                    if (r.IsFailure)
+                    {
+                        RecordError(nameof(ResourceBarrier), r.Error);
+                        continue;
+                    }
+
+                    ref var record = ref r.Value;
+                    var resource = record.ResourcePtr;
+                    pBufferBarriers[bufferIndex++] = new D3D12_BUFFER_BARRIER
+                    {
+                        SyncBefore = (D3D12_BARRIER_SYNC)desc.SyncBefore,
+                        SyncAfter = (D3D12_BARRIER_SYNC)desc.SyncAfter,
+                        AccessBefore = (D3D12_BARRIER_ACCESS)desc.AccessBefore,
+                        AccessAfter = (D3D12_BARRIER_ACCESS)desc.AccessAfter,
+                        pResource = resource,
+                        Offset = 0,
+                        Size = ulong.MaxValue
+                    };
+
+                    record.barrierData = new ResourceBarrierData(BarrierLayout.Undefined, desc.AccessAfter, desc.SyncAfter);
+                }
+                break;
+                case BarrierType.Texture:
+                {
+                    var r = _resourceDatabase.GetResourceRecord(desc.Resource);
+                    if (r.IsFailure)
+                    {
+                        RecordError(nameof(ResourceBarrier), r.Error);
+                        continue;
+                    }
+
+                    ref var record = ref r.Value;
+                    var resource = record.ResourcePtr;
+                    pTextureBarriers[textureIndex++] = new D3D12_TEXTURE_BARRIER
+                    {
+                        SyncBefore = (D3D12_BARRIER_SYNC)desc.SyncBefore,
+                        SyncAfter = (D3D12_BARRIER_SYNC)desc.SyncAfter,
+                        AccessBefore = (D3D12_BARRIER_ACCESS)desc.AccessBefore,
+                        AccessAfter = (D3D12_BARRIER_ACCESS)desc.AccessAfter,
+                        LayoutBefore = (D3D12_BARRIER_LAYOUT)desc.LayoutBefore,
+                        LayoutAfter = (D3D12_BARRIER_LAYOUT)desc.LayoutAfter,
+                        pResource = resource,
+                        Subresources = new D3D12_BARRIER_SUBRESOURCE_RANGE
+                        {
+                            IndexOrFirstMipLevel = desc.Subresources.IndexOrFirstMipLevel,
+                            NumMipLevels = desc.Subresources.NumMipLevels,
+                            FirstArraySlice = desc.Subresources.FirstArraySlice,
+                            NumArraySlices = desc.Subresources.NumArraySlices
+                        },
+                        Flags = desc.Discard ? D3D12_TEXTURE_BARRIER_FLAGS.D3D12_TEXTURE_BARRIER_FLAG_DISCARD : D3D12_TEXTURE_BARRIER_FLAGS.D3D12_TEXTURE_BARRIER_FLAG_NONE
+                    };
+
+                    record.barrierData = new ResourceBarrierData(desc.LayoutAfter, desc.AccessAfter, desc.SyncAfter);
+                }
+                break;
+            }
+        }
+
+        var groups = stackalloc D3D12_BARRIER_GROUP[3];
+        var groupCount = 0u;
+
+        if (globalCount > 0)
+        {
+            groups[groupCount] = new D3D12_BARRIER_GROUP
+            {
+                Type = D3D12_BARRIER_TYPE.D3D12_BARRIER_TYPE_GLOBAL,
+                NumBarriers = (uint)globalCount,
+            };
+            groups[groupCount].Anonymous.pGlobalBarriers = pGlobalBarriers;
+            groupCount++;
+        }
+
+        if (bufferCount > 0)
+        {
+            groups[groupCount] = new D3D12_BARRIER_GROUP
+            {
+                Type = D3D12_BARRIER_TYPE.D3D12_BARRIER_TYPE_BUFFER,
+                NumBarriers = (uint)bufferCount,
+            };
+            groups[groupCount].Anonymous.pBufferBarriers = pBufferBarriers;
+            groupCount++;
+        }
+
+        if (textureCount > 0)
+        {
+            groups[groupCount] = new D3D12_BARRIER_GROUP
+            {
+                Type = D3D12_BARRIER_TYPE.D3D12_BARRIER_TYPE_TEXTURE,
+                NumBarriers = (uint)textureCount,
+            };
+            groups[groupCount].Anonymous.pTextureBarriers = pTextureBarriers;
+            groupCount++;
+        }
+
+        _commandList.Get()->Barrier(groupCount, groups);
+    }
+
+    public void SetRenderTargets(ReadOnlySpan<Handle<Texture>> renderTargets, Handle<Texture> depthTarget)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var pRtvHandles = stackalloc D3D12_CPU_DESCRIPTOR_HANDLE[renderTargets.Length];
+        var rtvCount = 0u;
+        for (var i = 0; i < renderTargets.Length; i++)
+        {
+            var handle = renderTargets[i];
+            if (!handle.IsValid)
+            {
+                RecordError(nameof(SetRenderTargets), Error.InvalidArgument);
+                continue;
+            }
+
+            var recordResult = _resourceDatabase.GetResourceRecord(handle.AsResource());
+            if (recordResult.Error != Error.None)
+            {
+                RecordError(nameof(SetRenderTargets), recordResult.Error);
+                continue;
+            }
+
+            var viewGroup = recordResult.Value.viewGroup;
+            pRtvHandles[i] = _descriptorAllocator.GetCpuHandle(viewGroup.rtv);
+
+            rtvCount++;
+        }
+
+        var pDsvHandle = stackalloc D3D12_CPU_DESCRIPTOR_HANDLE[depthTarget.IsValid ? 1 : 0];
+        if (pDsvHandle != null)
+        {
+            var recordResult = _resourceDatabase.GetResourceRecord(depthTarget.AsResource());
+            if (recordResult.Error != Error.None)
+            {
+                RecordError(nameof(SetRenderTargets), recordResult.Error);
+                return;
+            }
+
+            var viewGroup = recordResult.Value.viewGroup;
+            pDsvHandle[0] = _descriptorAllocator.GetCpuHandle(viewGroup.dsv);
+        }
+
+        _commandList.Get()->OMSetRenderTargets(rtvCount, pRtvHandles, FALSE, pDsvHandle);
+    }
+
+    public void ClearRenderTargetView(Handle<Texture> renderTarget, Color128 clearColor)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var recordResult = _resourceDatabase.GetResourceRecord(renderTarget.AsResource());
+        if (recordResult.Error != Error.None)
+        {
+            RecordError(nameof(ClearRenderTargetView), recordResult.Error);
+            return;
+        }
+
+        ref var record = ref recordResult.Value;
+        var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.rtv);
+
+        _commandList.Get()->ClearRenderTargetView(cpuHandle, (float*)&clearColor, 0, null);
+    }
+
+    public void ClearDepthStencilView(Handle<Texture> depthStencil, bool inlcudeDepth, bool includeStencil, float clearDepth = 1.0f, byte clearStencil = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var recordResult = _resourceDatabase.GetResourceRecord(depthStencil.AsResource());
+        if (recordResult.Error != Error.None)
+        {
+            RecordError(nameof(ClearDepthStencilView), recordResult.Error);
+            return;
+        }
+
+        ref var record = ref recordResult.Value;
+        var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.dsv);
+        var flag = (inlcudeDepth ? D3D12_CLEAR_FLAG_DEPTH : 0) | (includeStencil ? D3D12_CLEAR_FLAG_STENCIL : 0);
+
+        _commandList.Get()->ClearDepthStencilView(cpuHandle,
+            flag,
+            clearDepth,
+            clearStencil,
+            0,
+            null);
+    }
+
+    public void BeginRenderPass(ReadOnlySpan<PassRenderTargetDesc> rtDescs, PassDepthStencilDesc depthDesc, bool allowUAVWrites = false)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var pRtvDescs = stackalloc D3D12_RENDER_PASS_RENDER_TARGET_DESC[rtDescs.Length];
+        for (var i = 0; i < rtDescs.Length; i++)
+        {
+            var rtDesc = rtDescs[i];
+            if (rtDesc.Texture.IsInvalid)
+            {
+                RecordError(nameof(BeginRenderPass), Error.InvalidArgument);
+                continue;
+            }
+
+            var recordResult = _resourceDatabase.GetResourceRecord(rtDesc.Texture.AsResource());
+            if (recordResult.Error != Error.None)
+            {
+                RecordError(nameof(BeginRenderPass), recordResult.Error);
+                continue;
+            }
+
+            ref var record = ref recordResult.Value;
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.rtv);
+            var format = record.desc.TextureDescription.Format.ToDXGIFormat();
+            var clearColor = rtDesc.ClearColor;
+
+            // Map load operation
+            var loadAccessType = rtDesc.LoadOp switch
+            {
+                AttachmentLoadOp.Load => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE,
+                AttachmentLoadOp.Clear => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR,
+                AttachmentLoadOp.DontCare => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE
+            };
+
+            // Map store operation
+            var storeAccessType = rtDesc.StoreOp switch
+            {
+                AttachmentStoreOp.Store => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE,
+                AttachmentStoreOp.DontCare => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE
+            };
+
+            var desc = new D3D12_RENDER_PASS_RENDER_TARGET_DESC
+            {
+                cpuDescriptor = cpuHandle,
+                BeginningAccess = new D3D12_RENDER_PASS_BEGINNING_ACCESS
+                {
+                    Type = loadAccessType,
+                    Clear = loadAccessType == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR
+                        ? new D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
+                        {
+                            ClearValue = new D3D12_CLEAR_VALUE(format, (float*)&clearColor)
+                        }
+                        : default
+                },
+                EndingAccess = new D3D12_RENDER_PASS_ENDING_ACCESS
+                {
+                    Type = storeAccessType
+                }
+            };
+
+            pRtvDescs[i] = desc;
+        }
+
+        var pDsvDesc = stackalloc D3D12_RENDER_PASS_DEPTH_STENCIL_DESC[depthDesc.Texture.IsValid ? 1 : 0];
+        if (pDsvDesc != null)
+        {
+            var recordResult = _resourceDatabase.GetResourceRecord(depthDesc.Texture.AsResource());
+            if (recordResult.Error != Error.None)
+            {
+                RecordError(nameof(BeginRenderPass), recordResult.Error);
+                return;
+            }
+
+            ref var record = ref recordResult.Value;
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(record.viewGroup.dsv);
+            var format = record.desc.TextureDescription.Format.ToDXGIFormat();
+
+            // Map depth load operation
+            var depthLoadAccessType = depthDesc.DepthLoadOp switch
+            {
+                AttachmentLoadOp.Load => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE,
+                AttachmentLoadOp.Clear => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR,
+                AttachmentLoadOp.DontCare => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE
+            };
+
+            // Map depth store operation
+            var depthStoreAccessType = depthDesc.DepthStoreOp switch
+            {
+                AttachmentStoreOp.Store => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE,
+                AttachmentStoreOp.DontCare => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE
+            };
+
+            // Map stencil load operation
+            var stencilLoadAccessType = depthDesc.StencilLoadOp switch
+            {
+                AttachmentLoadOp.Load => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE,
+                AttachmentLoadOp.Clear => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR,
+                AttachmentLoadOp.DontCare => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE
+            };
+
+            // Map stencil store operation
+            var stencilStoreAccessType = depthDesc.StencilStoreOp switch
+            {
+                AttachmentStoreOp.Store => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE,
+                AttachmentStoreOp.DontCare => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD,
+                _ => D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE
+            };
+
+            var desc = new D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
+            {
+                cpuDescriptor = cpuHandle,
+                DepthBeginningAccess = new D3D12_RENDER_PASS_BEGINNING_ACCESS
+                {
+                    Type = depthLoadAccessType,
+                    Clear = depthLoadAccessType == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR
+                        ? new D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
+                        {
+                            ClearValue = new D3D12_CLEAR_VALUE(format, depthDesc.ClearDepth, depthDesc.ClearStencil)
+                        }
+                        : default
+                },
+                DepthEndingAccess = new D3D12_RENDER_PASS_ENDING_ACCESS
+                {
+                    Type = depthStoreAccessType
+                },
+                StencilBeginningAccess = new D3D12_RENDER_PASS_BEGINNING_ACCESS
+                {
+                    Type = stencilLoadAccessType,
+                    Clear = stencilLoadAccessType == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR
+                        ? new D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
+                        {
+                            ClearValue = new D3D12_CLEAR_VALUE(format, depthDesc.ClearDepth, depthDesc.ClearStencil)
+                        }
+                        : default
+                },
+                StencilEndingAccess = new D3D12_RENDER_PASS_ENDING_ACCESS
+                {
+                    Type = stencilStoreAccessType
+                }
+            };
+
+            pDsvDesc[0] = desc;
+        }
+
+        _commandList.Get()->BeginRenderPass((uint)rtDescs.Length, pRtvDescs, pDsvDesc,
+                allowUAVWrites ? D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES : D3D12_RENDER_PASS_FLAG_NONE);
+    }
+
+    public void EndRenderPass()
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        _commandList.Get()->EndRenderPass();
+    }
+
+    public void SetViewport(ViewportDesc viewport)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var d3d12Viewport = new D3D12_VIEWPORT(viewport.X, viewport.Y, viewport.Width, viewport.Height, viewport.MinDepth, viewport.MaxDepth);
+        _commandList.Get()->RSSetViewports(1, &d3d12Viewport);
+    }
+
+    public void SetPipelineState(Key128<GraphicsPipeline> pipelineKey)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var psor = _pipelineLibrary.GetGraphicsPSO(pipelineKey);
+        if (psor.Error != Error.None)
+        {
+            RecordError(nameof(SetPipelineState), psor.Error);
+            return;
+        }
+
+        _commandList.Get()->SetGraphicsRootSignature(_pipelineLibrary.DefaultRootSignature);
+        _commandList.Get()->SetPipelineState(psor.Value);
+    }
+
+    public void SetConstantBufferView(uint slot, Handle<GraphicsBuffer> buffer)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var resource = _resourceDatabase.GetResource(buffer.AsResource());
+        _commandList.Get()->SetGraphicsRootConstantBufferView(slot, resource.Get()->GetGPUVirtualAddress());
+    }
+
+    public void SetVertexBuffer(uint slot, Handle<GraphicsBuffer> buffer, ulong offset = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var recordResult = _resourceDatabase.GetResourceRecord(buffer.AsResource());
+        if (recordResult.Error != Error.None)
+        {
+            RecordError(nameof(BeginRenderPass), recordResult.Error);
+            return;
+        }
+
+        ref var record = ref recordResult.Value;
+        var vbView = new D3D12_VERTEX_BUFFER_VIEW
+        {
+            BufferLocation = record.ResourcePtr.Get()->GetGPUVirtualAddress() + offset,
+            SizeInBytes = (uint)(record.ResourcePtr.Get()->GetDesc().Width - offset),
+            StrideInBytes = record.desc.BufferDescription.Stride
+        };
+
+        _commandList.Get()->IASetVertexBuffers(slot, 1, &vbView);
+    }
+
+    public void SetIndexBuffer(Handle<GraphicsBuffer> buffer, IndexType type, ulong offset = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var resource = _resourceDatabase.GetResource(buffer.AsResource());
+        var ibView = new D3D12_INDEX_BUFFER_VIEW
+        {
+            BufferLocation = resource.Get()->GetGPUVirtualAddress() + offset,
+            SizeInBytes = (uint)(resource.Get()->GetDesc().Width - offset),
+            Format = type == IndexType.UInt16 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT
+        };
+
+        _commandList.Get()->IASetIndexBuffer(&ibView);
+    }
+
+    public void SetPrimitiveTopology(PrimitiveTopology topology)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var d3d12Topology = topology switch
+        {
+            PrimitiveTopology.Point => D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
+            PrimitiveTopology.Line => D3D_PRIMITIVE_TOPOLOGY_LINELIST,
+            PrimitiveTopology.Triangle => D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
+            _ => D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST
+        };
+
+        _commandList.Get()->IASetPrimitiveTopology(d3d12Topology);
+    }
+
+    public void SetGraphicsRoot32Constants(uint rootIndex, ReadOnlySpan<uint> constantBuffer, uint offsetIn32Bits = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        fixed (uint* pConstants = constantBuffer)
+        {
+            _commandList.Get()->SetGraphicsRoot32BitConstants(rootIndex, (uint)constantBuffer.Length, pConstants, offsetIn32Bits);
+        }
+    }
+
+    public void Draw(uint vertexCount, uint instanceCount = 1, uint startVertex = 0, uint startInstance = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        _commandList.Get()->DrawInstanced(vertexCount, instanceCount, startVertex, startInstance);
+    }
+
+    public void DrawIndexed(uint indexCount, uint instanceCount = 1, uint startIndex = 0, int baseVertex = 0, uint startInstance = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        _commandList.Get()->DrawIndexedInstanced(indexCount, instanceCount, startIndex, baseVertex, startInstance);
+    }
+
+    public void DispatchCompute(uint threadGroupCountX, uint threadGroupCountY, uint threadGroupCountZ)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        _commandList.Get()->Dispatch(threadGroupCountX, threadGroupCountY, threadGroupCountZ);
+    }
+
+    public void DispatchMesh(uint threadGroupCountX, uint threadGroupCountY, uint threadGroupCountZ)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        _commandList.Get()->DispatchMesh(threadGroupCountX, threadGroupCountY, threadGroupCountZ);
+    }
+
+    public void DispatchRay()
+    {
+        throw new NotImplementedException();
+
+        // ThrowIfDisposed();
+        // ThrowIfNotRecording();
+        // IncrementCommandCount();
+
+        // _device.Get()->DispatchRays();
+    }
+
+    public void DispatchGraph()
+    {
+        throw new NotImplementedException();
+    }
+
+    public void ExecuteIndirect(Handle<GraphicsBuffer> argumentBuffer, ulong argumentOffset, Handle<GraphicsBuffer> countBuffer, ulong countBufferOffset)
+    {
+        throw new NotImplementedException();
+
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+
+        IncrementCommandCount();
+        var resource = _resourceDatabase.GetResource(argumentBuffer.AsResource());
+        var countResource = _resourceDatabase.GetResource(countBuffer.AsResource());
+        _commandList.Get()->ExecuteIndirect(null, 0,
+            resource, argumentOffset, countResource, countBufferOffset);
+
+    }
+
+    public void UploadBuffer<T>(Handle<GraphicsBuffer> buffer, params ReadOnlySpan<T> data)
+        where T : unmanaged
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var sizeInBytes = (uint)(data.Length * sizeof(T));
+
+        var uploadHandle = _resourceAllocator.CreateTempUploadBuffer(sizeInBytes, out var offset);
+        var uploadResource = _resourceDatabase.GetResource(uploadHandle.AsResource());
+
+        void* pMappedData;
+        uploadResource.Get()->Map(0, null, &pMappedData);
+        fixed (T* pData = data)
+        {
+            MemoryUtility.MemCpy((byte*)pMappedData + offset, pData, sizeInBytes);
+        }
+        uploadResource.Get()->Unmap(0, null);
+
+        var pResource = _resourceDatabase.GetResource(buffer.AsResource());
+        _commandList.Get()->CopyBufferRegion(pResource, 0, uploadResource, offset, sizeInBytes);
+    }
+
+    public void UploadTexture(Handle<Texture> texture, params ReadOnlySpan<SubResourceData> subresources)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var resource = _resourceDatabase.GetResource(texture.AsResource());
+
+        var resourceDesc = resource.Get()->GetDesc();
+        var requiredSize = GetRequiredIntermediateSize(resource, 0, (uint)subresources.Length);
+
+        var uploadHandle = _resourceAllocator.CreateTempUploadBuffer(requiredSize, out var offset);
+        var pUploadResource = _resourceDatabase.GetResource(uploadHandle.AsResource());
+
+        var d3d12Subresources = stackalloc D3D12_SUBRESOURCE_DATA[subresources.Length];
+        for (var i = 0; i < subresources.Length; i++)
+        {
+            d3d12Subresources[i] = new D3D12_SUBRESOURCE_DATA
+            {
+                pData = subresources[i].pData,
+                RowPitch = (nint)subresources[i].rowPitch,
+                SlicePitch = (nint)subresources[i].slicePitch
+            };
+        }
+
+        UpdateSubresources(
+            (ID3D12GraphicsCommandList*)_commandList.Get(),
+            resource,
+            pUploadResource,
+            offset,
+            0,
+            (uint)subresources.Length,
+            d3d12Subresources);
+    }
+
+    public void CopyBuffer(Handle<GraphicsBuffer> dest, Handle<GraphicsBuffer> src, ulong destOffset = 0, ulong srcOffset = 0, ulong numBytes = 0)
+    {
+        ThrowIfDisposed();
+        ThrowIfNotRecording();
+#if !DEBUG
+        if (_lastError.Status != Error.None)
+        {
+            return;
+        }
+#endif
+        IncrementCommandCount();
+
+        var pDestResource = _resourceDatabase.GetResource(dest.AsResource());
+        var pSrcResource = _resourceDatabase.GetResource(src.AsResource());
+        if (pSrcResource == null || pDestResource == null)
+        {
+            RecordError(nameof(CopyBuffer), Error.InvalidArgument);
+            return;
+        }
+
+        if (numBytes == 0)
+        {
+            _commandList.Get()->CopyResource(pDestResource, pSrcResource);
+        }
+        else
+        {
+            _commandList.Get()->CopyBufferRegion(pDestResource, destOffset, pSrcResource, srcOffset, numBytes);
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (_isRecording)
+        {
+            throw new InvalidOperationException("Command buffer is still recording");
+        }
+
+        _commandList.Dispose();
+        _commandCount = 0;
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12CommandQueue.cs

@@ -0,0 +1,181 @@
+using Ghost.Core.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of command queue interface
+/// </summary>
+internal unsafe class D3D12CommandQueue : ICommandQueue
+{
+    private UniquePtr<ID3D12CommandQueue> _commandQueue;
+    private UniquePtr<ID3D12Fence1> _fence;
+
+    private readonly AutoResetEvent _fenceEvent;
+    private ulong _fenceValue;
+    private bool _disposed;
+
+    public CommandQueueType Type
+    {
+        get;
+    }
+
+    public SharedPtr<ID3D12CommandQueue> NativeQueue => _commandQueue.Get();
+
+    public D3D12CommandQueue(ID3D12Device14* pDevice, CommandQueueType type)
+    {
+        Type = type;
+        _fenceEvent = new AutoResetEvent(false);
+        _fenceValue = 0;
+
+        var queueDesc = new D3D12_COMMAND_QUEUE_DESC
+        {
+            Type = ConvertCommandQueueType(type),
+            Priority = (int)D3D12_COMMAND_QUEUE_PRIORITY.D3D12_COMMAND_QUEUE_PRIORITY_NORMAL,
+            Flags = D3D12_COMMAND_QUEUE_FLAGS.D3D12_COMMAND_QUEUE_FLAG_NONE,
+        };
+
+        ID3D12CommandQueue* pQueue = default;
+        ID3D12Fence1* pFence = default;
+        ThrowIfFailed(pDevice->CreateCommandQueue(&queueDesc, __uuidof(pQueue), (void**)&pQueue));
+        ThrowIfFailed(pDevice->CreateFence(0, D3D12_FENCE_FLAGS.D3D12_FENCE_FLAG_NONE, __uuidof(pFence), (void**)&pFence));
+
+        _commandQueue.Attach(pQueue);
+        _fence.Attach(pFence);
+    }
+
+    ~D3D12CommandQueue()
+    {
+        Dispose();
+    }
+
+    private static D3D12_COMMAND_LIST_TYPE ConvertCommandQueueType(CommandQueueType type)
+    {
+        return type switch
+        {
+            CommandQueueType.Graphics => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_DIRECT,
+            CommandQueueType.Compute => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COMPUTE,
+            CommandQueueType.Copy => D3D12_COMMAND_LIST_TYPE.D3D12_COMMAND_LIST_TYPE_COPY,
+            _ => throw new ArgumentException($"Unknown command queue type: {type}")
+        };
+    }
+
+    public void Submit(ICommandBuffer commandBuffer)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (commandBuffer.IsEmpty)
+        {
+            return;
+        }
+
+        if (commandBuffer is D3D12CommandBuffer d3d12CommandBuffer)
+        {
+            var commandList = d3d12CommandBuffer.NativeCommandList;
+            var commandListPtr = (ID3D12CommandList*)commandList.Get();
+            _commandQueue.Get()->ExecuteCommandLists(1, &commandListPtr);
+        }
+        else
+        {
+            throw new ArgumentException("Command buffer must be a D3D12CommandBuffer", nameof(commandBuffer));
+        }
+    }
+
+    public void Submit(params ReadOnlySpan<ICommandBuffer> commandBuffers)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        Span<int> executableIndices = stackalloc int[commandBuffers.Length];
+        executableIndices.Fill(-1);
+
+        var currentIndex = 0;
+        for (var i = 0; i < commandBuffers.Length; i++)
+        {
+            if (!commandBuffers[i].IsEmpty)
+            {
+                executableIndices[currentIndex] = i;
+                currentIndex++;
+            }
+        }
+
+        var ppCommandLists = stackalloc ID3D12CommandList*[commandBuffers.Length];
+
+        currentIndex = 0;
+        while (currentIndex < commandBuffers.Length)
+        {
+            var cmdIndex = executableIndices[currentIndex];
+            if (cmdIndex == -1)
+            {
+                break;
+            }
+
+            if (commandBuffers[cmdIndex] is D3D12CommandBuffer d3d12CommandBuffer)
+            {
+                ppCommandLists[currentIndex] = (ID3D12CommandList*)d3d12CommandBuffer.NativeCommandList.Get();
+            }
+            else
+            {
+                throw new ArgumentException("Command buffer must be a D3D12CommandBuffer", nameof(commandBuffers));
+            }
+
+            currentIndex++;
+        }
+
+        _commandQueue.Get()->ExecuteCommandLists((uint)currentIndex, ppCommandLists);
+    }
+
+    public ulong Signal(ulong value)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        _fenceValue = value;
+        ThrowIfFailed(_commandQueue.Get()->Signal((ID3D12Fence*)_fence.Get(), _fenceValue));
+        return _fenceValue;
+    }
+
+    public void WaitForValue(ulong value)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (_fence.Get()->GetCompletedValue() < value)
+        {
+            var handle = new HANDLE((void*)_fenceEvent.SafeWaitHandle.DangerousGetHandle());
+            if (_fence.Get()->SetEventOnCompletion(value, handle).SUCCEEDED)
+            {
+                _fenceEvent.WaitOne();
+            }
+        }
+    }
+
+    public ulong GetCompletedValue()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _fence.Get()->GetCompletedValue();
+    }
+
+    public void WaitIdle()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var fenceValue = Signal(Interlocked.Increment(ref _fenceValue));
+        WaitForValue(fenceValue);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _commandQueue.Dispose();
+        _fence.Dispose();
+        _fenceEvent?.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12DebugLayer.cs

@@ -0,0 +1,44 @@
+using Ghost.Core.Utilities;
+using Misaki.HighPerformance.LowLevel;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Aliases.DXGI_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+internal unsafe class D3D12DebugLayer
+{
+    private UniquePtr<ID3D12Debug6> _d3d12Debug;
+    private UniquePtr<IDXGIDebug1> _dxgiDebug;
+    private UniquePtr<IDXGIInfoQueue> _dxgiInfoQueue;
+
+    public D3D12DebugLayer()
+    {
+        ID3D12Debug6* pDebug = default;
+        ThrowIfFailed(D3D12GetDebugInterface(__uuidof(pDebug), (void**)&pDebug));
+        pDebug->EnableDebugLayer();
+
+        IDXGIDebug1* pDxgiDebug = default;
+        ThrowIfFailed(DXGIGetDebugInterface1(0u, __uuidof(pDxgiDebug), (void**)&pDxgiDebug));
+        pDxgiDebug->EnableLeakTrackingForThread();
+
+        IDXGIInfoQueue* pDxgiInfoQueue = default;
+        ThrowIfFailed(DXGIGetDebugInterface1(0u, __uuidof(pDxgiInfoQueue), (void**)&pDxgiInfoQueue));
+        ThrowIfFailed(pDxgiInfoQueue->SetBreakOnSeverity(DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, true));
+        ThrowIfFailed(pDxgiInfoQueue->SetBreakOnSeverity(DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, true));
+
+        _d3d12Debug.Attach(pDebug);
+        _dxgiDebug.Attach(pDxgiDebug);
+        _dxgiInfoQueue.Attach(pDxgiInfoQueue);
+    }
+
+    public void Dispose()
+    {
+        ThrowIfFailed(_dxgiDebug.Get()->ReportLiveObjects(DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL | DXGI_DEBUG_RLO_IGNORE_INTERNAL));
+
+        _d3d12Debug.Dispose();
+        _dxgiDebug.Dispose();
+        _dxgiInfoQueue.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12DescriptorAllocator.cs

@@ -0,0 +1,379 @@
+using Ghost.Core;
+using System.Runtime.CompilerServices;
+using TerraFX.Interop.DirectX;
+
+using static TerraFX.Aliases.D3D12_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of viewGroup allocator that manages different types of viewGroup heaps.
+/// </summary>
+internal unsafe class D3D12DescriptorAllocator : IDisposable
+{
+    private readonly D3D12DescriptorHeap _rtvHeap;
+    private readonly D3D12DescriptorHeap _dsvHeap;
+    private readonly D3D12DescriptorHeap _cbvSrvUavHeap;
+    private readonly D3D12DescriptorHeap _samplerHeap;
+
+    private bool _disposed;
+
+    public D3D12DescriptorAllocator(D3D12RenderDevice device, int initialRtvCount = 512, int initialDsvCount = 512, int initialSrvCount = 200_000, int initialSamplerCount = 256)
+    {
+        _rtvHeap = new D3D12DescriptorHeap("rtv", device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, initialRtvCount);
+        _dsvHeap = new D3D12DescriptorHeap("dsv", device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, initialDsvCount);
+        _cbvSrvUavHeap = new D3D12DescriptorHeap("srv", device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, initialSrvCount);
+        _samplerHeap = new D3D12DescriptorHeap("sampler", device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, initialSamplerCount);
+    }
+
+    ~D3D12DescriptorAllocator()
+    {
+        Dispose();
+    }
+
+    #region RTV Methods
+
+    public Identifier<RTVDescriptor> AllocateRTV()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var index = _rtvHeap.AllocateDescriptor();
+        if (index == -1)
+        {
+            throw new InvalidOperationException("Failed to allocate RTV descriptor");
+        }
+
+        return new Identifier<RTVDescriptor>(index);
+    }
+
+    public Identifier<RTVDescriptor>[] AllocateRTVs(int count)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var baseIndex = _rtvHeap.AllocateDescriptors(count);
+        if (baseIndex == -1)
+        {
+            throw new InvalidOperationException($"Failed to allocate {count} RTV descriptors");
+        }
+
+        var descriptors = new Identifier<RTVDescriptor>[count];
+        for (var i = 0; i < count; i++)
+        {
+            var index = baseIndex + i;
+            descriptors[i] = new Identifier<RTVDescriptor>(index);
+        }
+
+        return descriptors;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(Identifier<RTVDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _rtvHeap.GetCpuHandle(descriptor.Value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Release(Identifier<RTVDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _rtvHeap.ReleaseDescriptor(descriptor.Value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Release(ReadOnlySpan<Identifier<RTVDescriptor>> descriptors)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        foreach (var descriptor in descriptors)
+        {
+            Release(descriptor);
+        }
+    }
+
+    #endregion
+
+    #region DSV Methods
+
+    public Identifier<DSVDescriptor> AllocateDSV()  
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var index = _dsvHeap.AllocateDescriptor();
+        if (index == -1)
+        {
+            throw new InvalidOperationException("Failed to allocate DSV descriptor");
+        }
+
+        return new Identifier<DSVDescriptor>(index);
+    }
+
+    public Identifier<DSVDescriptor>[] AllocateDSVs(int count)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var baseIndex = _dsvHeap.AllocateDescriptors(count);
+        if (baseIndex == -1)
+        {
+            throw new InvalidOperationException($"Failed to allocate {count} DSV descriptors");
+        }
+
+        var descriptors = new Identifier<DSVDescriptor>[count];
+        for (var i = 0; i < count; i++)
+        {
+            var index = baseIndex + i;
+            descriptors[i] = new Identifier<DSVDescriptor>(index);
+        }
+
+        return descriptors;
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(Identifier<DSVDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _dsvHeap.GetCpuHandle(descriptor.Value);
+    }
+
+    public void Release(Identifier<DSVDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _dsvHeap.ReleaseDescriptor(descriptor.Value);
+    }
+
+    public void Release(ReadOnlySpan<Identifier<DSVDescriptor>> descriptors)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        foreach (var descriptor in descriptors)
+        {
+            Release(descriptor);
+        }
+    }
+
+    #endregion
+
+    #region CBV_SRV_UAV Methods
+
+    public Identifier<CbvSrvUavDescriptor> AllocateCbvSrvUav()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var index = _cbvSrvUavHeap.AllocateDescriptor();
+        if (index == -1)
+        {
+            throw new InvalidOperationException("Failed to allocate CBV/SRV/UAV descriptor");
+        }
+
+        return new Identifier<CbvSrvUavDescriptor>(index);
+    }
+
+    public Identifier<CbvSrvUavDescriptor>[] AllocateSRVs(int count)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var baseIndex = _cbvSrvUavHeap.AllocateDescriptors(count);
+        if (baseIndex == -1)
+        {
+            throw new InvalidOperationException($"Failed to allocate {count} CBV/SRV/UAV descriptors");
+        }
+
+        var descriptors = new Identifier<CbvSrvUavDescriptor>[count];
+        for (var i = 0; i < count; i++)
+        {
+            var index = baseIndex + i;
+            descriptors[i] = new Identifier<CbvSrvUavDescriptor>(index);
+        }
+
+        return descriptors;
+    }
+
+    public void CopyToShaderVisible(Identifier<CbvSrvUavDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _cbvSrvUavHeap.CopyToShaderVisibleHeap(descriptor.Value);
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(Identifier<CbvSrvUavDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _cbvSrvUavHeap.GetCpuHandle(descriptor.Value);
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandleShaderVisible(Identifier<CbvSrvUavDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _cbvSrvUavHeap.GetCpuHandleShaderVisible(descriptor.Value);
+    }
+
+    public D3D12_GPU_DESCRIPTOR_HANDLE GetGpuHandle(Identifier<CbvSrvUavDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _cbvSrvUavHeap.GetGpuHandle(descriptor.Value);
+    }
+
+    public void Release(Identifier<CbvSrvUavDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _cbvSrvUavHeap.ReleaseDescriptor(descriptor.Value);
+    }
+
+    public void Release(ReadOnlySpan<Identifier<CbvSrvUavDescriptor>> descriptors)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        foreach (var descriptor in descriptors)
+        {
+            Release(descriptor);
+        }
+    }
+
+    #endregion
+
+    #region Sampler Methods
+
+    public Identifier<SamplerDescriptor> AllocateSampler()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var index = _samplerHeap.AllocateDescriptor();
+        if (index == -1)
+        {
+            throw new InvalidOperationException("Failed to allocate Sampler descriptor");
+        }
+
+        return new Identifier<SamplerDescriptor>(index);
+    }
+
+    public Identifier<SamplerDescriptor>[] AllocateSamplers(int count)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var baseIndex = _samplerHeap.AllocateDescriptors(count);
+        if (baseIndex == -1)
+        {
+            throw new InvalidOperationException($"Failed to allocate {count} Sampler descriptors");
+        }
+
+        var descriptors = new Identifier<SamplerDescriptor>[count];
+        for (var i = 0; i < count; i++)
+        {
+            var index = baseIndex + i;
+            descriptors[i] = new Identifier<SamplerDescriptor>(index);
+        }
+
+        return descriptors;
+    }
+
+    public void CopyToShaderVisible(Identifier<SamplerDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _samplerHeap.CopyToShaderVisibleHeap(descriptor.Value);
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(Identifier<SamplerDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _samplerHeap.GetCpuHandle(descriptor.Value);
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandleShaderVisible(Identifier<SamplerDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _samplerHeap.GetCpuHandleShaderVisible(descriptor.Value);
+    }
+
+    public D3D12_GPU_DESCRIPTOR_HANDLE GetGpuHandle(Identifier<SamplerDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _samplerHeap.GetGpuHandle(descriptor.Value);
+    }
+
+    public void Release(Identifier<SamplerDescriptor> descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        _samplerHeap.ReleaseDescriptor(descriptor.Value);
+    }
+
+    public void Release(ReadOnlySpan<Identifier<SamplerDescriptor>> descriptors)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        foreach (var descriptor in descriptors)
+        {
+            Release(descriptor);
+        }
+    }
+
+    #endregion
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Release(ResourceViewGroup descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        Release(descriptor.rtv);
+        Release(descriptor.dsv);
+        Release(descriptor.srv);
+        Release(descriptor.cbv);
+        Release(descriptor.uav);
+        Release(descriptor.sampler);
+    }
+
+    #region Utility Methods
+
+    /// <summary>
+    /// Gets the RTV Heap for binding to the command list.
+    /// </summary>
+    public ID3D12DescriptorHeap* GetRTVHeap() => _rtvHeap.Heap;
+
+    /// <summary>
+    /// Gets the DSV Heap for binding to the command list.
+    /// </summary>
+    public ID3D12DescriptorHeap* GetDSVHeap() => _dsvHeap.Heap;
+
+    /// <summary>
+    /// Gets the CBV/SRV/UAV Heap for binding to the command list.
+    /// </summary>
+    public ID3D12DescriptorHeap* GetCbvSrvUavHeap() => _cbvSrvUavHeap.ShaderVisibleHeap;
+
+    /// <summary>
+    /// Gets the sampler Heap for binding to the command list.
+    /// </summary>
+    public ID3D12DescriptorHeap* GetSamplerHeap() => _samplerHeap.ShaderVisibleHeap;
+
+    /// <summary>
+    /// Gets the shader visible heaps that need to be bound to the command list.
+    /// </summary>
+    /// <param name="ppHeap">An array of two ID3D12DescriptorHeap pointers to receive the CBV/SRV/UAV and Sampler heaps.</param>
+    public void GetShaderVisibleHeaps(ID3D12DescriptorHeap** ppHeap)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (ppHeap == null)
+        {
+            throw new ArgumentNullException(nameof(ppHeap));
+        }
+
+        ppHeap[0] = _cbvSrvUavHeap.ShaderVisibleHeap;
+        ppHeap[1] = _samplerHeap.ShaderVisibleHeap;
+    }
+
+    #endregion
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _rtvHeap.Dispose();
+        _dsvHeap.Dispose();
+        _cbvSrvUavHeap.Dispose();
+        _samplerHeap.Dispose();
+
+        _disposed = true;
+
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12DescriptorHeap.cs

@@ -0,0 +1,307 @@
+using Ghost.Core.Utilities;
+using Ghost.Graphics.D3D12.Utilities;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Diagnostics;
+using System.Numerics;
+using TerraFX.Interop.DirectX;
+
+using static TerraFX.Aliases.D3D12_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+internal unsafe class D3D12DescriptorHeap : IDisposable
+{
+    private const int _INVALID_DESCRIPTOR_INDEX = -1;
+
+    private readonly D3D12RenderDevice _device;
+
+    private UniquePtr<ID3D12DescriptorHeap> _heap;
+    private UniquePtr<ID3D12DescriptorHeap> _shaderVisibleHeap;
+    private D3D12_CPU_DESCRIPTOR_HANDLE _startCpuHandle;
+    private D3D12_CPU_DESCRIPTOR_HANDLE _startCpuHandleShaderVisible;
+    private D3D12_GPU_DESCRIPTOR_HANDLE _startGpuHandleShaderVisible;
+    private int _searchStart;
+    private UnsafeBitSet _allocatedDescriptors;
+
+    private readonly Lock _lock = new();
+
+    public D3D12_DESCRIPTOR_HEAP_TYPE HeapType
+    {
+        get;
+    }
+
+    public int NumDescriptors
+    {
+        get; private set;
+    }
+
+    public int NumAllocatedDescriptors
+    {
+        get; private set;
+    }
+
+    public bool ShaderVisible
+    {
+        get;
+    }
+
+    public uint Stride
+    {
+        get;
+    }
+
+    public ID3D12DescriptorHeap* Heap => _heap.Get();
+    public ID3D12DescriptorHeap* ShaderVisibleHeap => _shaderVisibleHeap.Get();
+
+    public D3D12DescriptorHeap(string name, D3D12RenderDevice device, D3D12_DESCRIPTOR_HEAP_TYPE type, int numDescriptors)
+    {
+        numDescriptors = Math.Max(64, numDescriptors);
+
+        _device = device;
+
+        HeapType = type;
+        NumDescriptors = numDescriptors;
+        ShaderVisible = type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV || type == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
+        Stride = device.NativeDevice.Get()->GetDescriptorHandleIncrementSize(type);
+
+        var success = AllocateResources(numDescriptors);
+        Debug.Assert(success);
+
+        _heap.Get()->SetName(name);
+        if (ShaderVisible)
+        {
+            _shaderVisibleHeap.Get()->SetName($"{name} Shader Visible");
+        }
+    }
+
+    public int AllocateDescriptor() => AllocateDescriptors(1);
+
+    public int AllocateDescriptors(int count)
+    {
+        lock (_lock)
+        {
+            var foundIndex = 0;
+            uint freeCount = 0;
+            var found = false;
+
+            // Find a contiguous range of 'count' indices for which _allocatedDescriptors[index] is false
+            for (var index = _searchStart; index < NumDescriptors; index++)
+            {
+                if (_allocatedDescriptors.IsSet(index))
+                {
+                    freeCount = 0;
+                }
+                else
+                {
+                    freeCount += 1;
+                }
+
+                if (freeCount >= count)
+                {
+                    foundIndex = index > 0 ? index - count + 1 : 0;
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found)
+            {
+                foundIndex = NumDescriptors;
+
+                if (!Grow(NumDescriptors + count))
+                {
+                    Debug.WriteLine("Error: Failed to grow descriptor heap.");
+                    return _INVALID_DESCRIPTOR_INDEX;
+                }
+            }
+
+            for (var index = foundIndex; index < foundIndex + count; index++)
+            {
+                _allocatedDescriptors.SetBit(index);
+            }
+
+            NumAllocatedDescriptors += count;
+            _searchStart = foundIndex + count;
+            return foundIndex;
+        }
+    }
+
+    public void ReleaseDescriptor(int index) => ReleaseDescriptors(index, 1);
+
+    public void ReleaseDescriptors(int baseIndex, int count = 1)
+    {
+        if (baseIndex == _INVALID_DESCRIPTOR_INDEX)
+        {
+            return;
+        }
+
+        if (count == 0)
+        {
+            return;
+        }
+
+        lock (_lock)
+        {
+            for (var index = baseIndex; index < baseIndex + count; index++)
+            {
+#if DEBUG || GHOST_EDITOR
+                if (!_allocatedDescriptors.IsSet(index))
+                {
+                    Debug.WriteLine("Error: Attempted to release an un-allocated descriptor");
+                }
+#endif
+
+                _allocatedDescriptors.ClearBit(index);
+            }
+
+            NumAllocatedDescriptors -= count;
+
+            if (_searchStart > baseIndex)
+            {
+                _searchStart = baseIndex;
+            }
+        }
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(int index)
+    {
+        if (index < 0 || index >= NumDescriptors)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), "Descriptor index is out of range.");
+        }
+
+        var handle = _startCpuHandle;
+        return handle.Offset(index, Stride);
+    }
+
+    public D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandleShaderVisible(int index)
+    {
+        if (index < 0 || index >= NumDescriptors)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), "Descriptor index is out of range.");
+        }
+
+        if (!ShaderVisible)
+        {
+            throw new InvalidOperationException("Descriptor heap is not shader visible.");
+        }
+
+        var handle = _startCpuHandleShaderVisible;
+        return handle.Offset(index, Stride);
+    }
+
+    public D3D12_GPU_DESCRIPTOR_HANDLE GetGpuHandle(int index)
+    {
+        if (index < 0 || index >= NumDescriptors)
+        {
+            throw new ArgumentOutOfRangeException(nameof(index), "Descriptor index is out of range.");
+        }
+
+        if (!ShaderVisible)
+        {
+            throw new InvalidOperationException("Descriptor heap is not shader visible.");
+        }
+
+        var handle = _startGpuHandleShaderVisible;
+        return handle.Offset(index, Stride);
+    }
+
+    public void CopyToShaderVisibleHeap(int index, int count = 1)
+    {
+        _device.NativeDevice.Get()->CopyDescriptorsSimple((uint)count, GetCpuHandleShaderVisible(index), GetCpuHandle(index), HeapType);
+    }
+
+    private bool AllocateResources(int numDescriptors)
+    {
+        NumDescriptors = numDescriptors;
+        _heap.Dispose();
+        _shaderVisibleHeap.Dispose();
+
+        D3D12_DESCRIPTOR_HEAP_DESC heapDesc = new()
+        {
+            Type = HeapType,
+            NumDescriptors = (uint)numDescriptors,
+            Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE,
+            NodeMask = 0
+        };
+
+        ID3D12DescriptorHeap* pHeap = default;
+        var hr = _device.NativeDevice.Get()->CreateDescriptorHeap(&heapDesc, __uuidof(pHeap), (void**)&pHeap);
+        if (hr.FAILED)
+        {
+            return false;
+        }
+
+        _heap.Attach(pHeap);
+
+        _startCpuHandle = _heap.Get()->GetCPUDescriptorHandleForHeapStart();
+
+        if (!_allocatedDescriptors.IsCreated)
+        {
+            _allocatedDescriptors = new UnsafeBitSet(numDescriptors, Misaki.HighPerformance.LowLevel.Buffer.Allocator.Persistent, Misaki.HighPerformance.LowLevel.Buffer.AllocationOption.Clear);
+        }
+        else
+        {
+            _allocatedDescriptors.Resize(numDescriptors, Misaki.HighPerformance.LowLevel.Buffer.AllocationOption.Clear);
+        }
+
+        if (ShaderVisible)
+        {
+            ID3D12DescriptorHeap* pShaderVisibleHeap = default;
+
+            heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+            hr = _device.NativeDevice.Get()->CreateDescriptorHeap(&heapDesc, __uuidof(pShaderVisibleHeap), (void**)&pShaderVisibleHeap);
+            if (hr.FAILED)
+            {
+                return false;
+            }
+
+            _startCpuHandleShaderVisible = pShaderVisibleHeap->GetCPUDescriptorHandleForHeapStart();
+            _startGpuHandleShaderVisible = pShaderVisibleHeap->GetGPUDescriptorHandleForHeapStart();
+
+            _shaderVisibleHeap.Attach(pShaderVisibleHeap);
+        }
+
+        return true;
+    }
+
+    private bool Grow(int minRequiredSize)
+    {
+        var oldSize = NumDescriptors;
+        var newSize = (int)BitOperations.RoundUpToPowerOf2((uint)minRequiredSize);
+
+        var oldHeap = _heap.Detach();
+
+        try
+        {
+            if (!AllocateResources(newSize))
+            {
+                return false;
+            }
+
+            _device.NativeDevice.Get()->CopyDescriptorsSimple((uint)oldSize, _startCpuHandle, oldHeap->GetCPUDescriptorHandleForHeapStart(), HeapType);
+
+            if (_shaderVisibleHeap.Get() != null)
+            {
+                _device.NativeDevice.Get()->CopyDescriptorsSimple((uint)oldSize, _startCpuHandleShaderVisible, oldHeap->GetCPUDescriptorHandleForHeapStart(), HeapType);
+            }
+        }
+        finally
+        {
+            oldHeap->Release();
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Debug.Assert(NumAllocatedDescriptors == 0);
+
+        _heap.Dispose();
+        _shaderVisibleHeap.Dispose();
+        _allocatedDescriptors.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12GraphicsEngine.cs

@@ -0,0 +1,161 @@
+#if DEBUG
+#define ENABLE_DEBUG
+#endif
+
+using Ghost.Core;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.Core;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Graphics.D3D12;
+
+internal class D3D12GraphicsEngine : IGraphicsEngine
+{
+    private readonly IRenderSystem _renderSystem;
+
+#if ENABLE_DEBUG
+    private readonly D3D12DebugLayer _debugLayer;
+#endif
+
+    private readonly D3D12RenderDevice _device;
+    private readonly DxcShaderCompiler _shaderCompiler;
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+    private readonly D3D12PipelineLibrary _pipelineLibrary;
+    private readonly D3D12ResourceAllocator _resourceAllocator;
+
+    private ImmutableArray<IRenderer> _renderers;
+
+    private bool _disposed;
+
+    public IRenderDevice Device => _device;
+    public IShaderCompiler ShaderCompiler => _shaderCompiler;
+    public IPipelineLibrary PipelineLibrary => _pipelineLibrary;
+    public IResourceDatabase ResourceDatabase => _resourceDatabase;
+    public IResourceAllocator ResourceAllocator => _resourceAllocator;
+
+    public D3D12GraphicsEngine(IRenderSystem renderSystem)
+    {
+        _renderSystem = renderSystem;
+
+#if ENABLE_DEBUG
+        _debugLayer = new D3D12DebugLayer();
+#endif
+        _device = new D3D12RenderDevice();
+        _shaderCompiler = new DxcShaderCompiler();
+        _descriptorAllocator = new D3D12DescriptorAllocator(_device);
+
+        _resourceDatabase = new D3D12ResourceDatabase(_descriptorAllocator);
+        _pipelineLibrary = new D3D12PipelineLibrary(_device, _resourceDatabase);
+        _resourceAllocator = new D3D12ResourceAllocator(renderSystem, _device, _descriptorAllocator, _resourceDatabase, _pipelineLibrary);
+
+        _renderers = ImmutableArray<IRenderer>.Empty;
+
+        _pipelineLibrary.InitializeLibrary(null);
+    }
+
+    ~D3D12GraphicsEngine()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ThrowIfDisposed()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+    }
+
+    public IRenderer CreateRenderer()
+    {
+        ThrowIfDisposed();
+
+        var renderer = new D3D12Renderer(this, _resourceDatabase);
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Add(renderer));
+        return renderer;
+    }
+
+    public void RemoveRenderer(IRenderer renderer)
+    {
+        ThrowIfDisposed();
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Remove(renderer));
+    }
+
+    public void ClearRenderers()
+    {
+        ThrowIfDisposed();
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Clear());
+    }
+
+    public ICommandAllocator CreateCommandAllocator(CommandBufferType type = CommandBufferType.Graphics)
+    {
+        return new D3D12CommandAllocator(_device, type);
+    }
+
+    public ICommandBuffer CreateCommandBuffer(CommandBufferType type = CommandBufferType.Graphics)
+    {
+        ThrowIfDisposed();
+
+        return new D3D12CommandBuffer(
+            _device,
+            _pipelineLibrary,
+            _resourceDatabase,
+            _resourceAllocator,
+            _descriptorAllocator,
+            type);
+    }
+
+    public ISwapChain CreateSwapChain(SwapChainDesc desc)
+    {
+        ThrowIfDisposed();
+        return new D3D12SwapChain(_resourceDatabase, _descriptorAllocator, _device, desc, _renderSystem.MaxFrameLatency);
+    }
+
+    public Result RenderFrame(ICommandAllocator commandAllocator)
+    {
+        ThrowIfDisposed();
+
+        var r = Result.Success();
+
+        foreach (var renderer in _renderers)
+        {
+            r = renderer.Render(commandAllocator);
+            if (r.IsFailure)
+            {
+                break;
+            }
+        }
+
+        _resourceAllocator.ReleaseTempResources();
+
+        return r;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        foreach (var renderer in _renderers)
+        {
+            renderer.Dispose();
+        }
+
+        _resourceAllocator.Dispose();
+        _pipelineLibrary.Dispose();
+        _resourceDatabase.Dispose();
+
+        _descriptorAllocator.Dispose();
+        _shaderCompiler.Dispose();
+        _device.Dispose();
+#if ENABLE_DEBUG
+        _debugLayer.Dispose();
+#endif
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12PipelineLibrary.cs

@@ -0,0 +1,356 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Core.Utilities;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Runtime.InteropServices;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Aliases.D3D_Alias;
+using static TerraFX.Aliases.D3D12_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+internal struct D3D12PipelineState : IDisposable
+{
+    public D3DX12_MESH_SHADER_PIPELINE_STATE_DESC psoDesc;
+    public UniquePtr<ID3D12PipelineState> pso;
+    public Key64<ShaderVariant> shaderVariant;
+
+    public void Dispose()
+    {
+        pso.Dispose();
+    }
+}
+
+internal unsafe class D3D12PipelineLibrary : IPipelineLibrary
+{
+    private readonly D3D12RenderDevice _device;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+
+    private UniquePtr<ID3D12PipelineLibrary1> _library;
+    private UniquePtr<ID3D12RootSignature> _defaultRootSignature;
+
+    private readonly Dictionary<Key128<GraphicsPipeline>, D3D12PipelineState> _pipelineCache;
+
+    public ID3D12RootSignature* DefaultRootSignature => _defaultRootSignature.Get();
+
+    public D3D12PipelineLibrary(D3D12RenderDevice device, D3D12ResourceDatabase resourceDatabase)
+    {
+        _device = device;
+        _resourceDatabase = resourceDatabase;
+
+        _pipelineCache = new Dictionary<Key128<GraphicsPipeline>, D3D12PipelineState>();
+
+        CreateDefaultRootSignature().ThrowIfFailed();
+    }
+
+    // TODO: Maybe we don't need 4 root signature. We can use bindless for global, per-view, and per-object buffers as well.
+    private Result CreateDefaultRootSignature()
+    {
+        _defaultRootSignature = default;
+
+        // NOTE: Since we are targeting SM 6.6, we can use ResourceDescriptorHeap and SamplerDescriptorHeap directly without needing to set up viewGroup tables.
+        var rootParameters = stackalloc D3D12_ROOT_PARAMETER1[RootSignatureLayout.ROOT_PARAMETER_COUNT];
+
+        rootParameters[0] = new D3D12_ROOT_PARAMETER1
+        {
+            ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS,
+            ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
+            Constants = new D3D12_ROOT_CONSTANTS
+            {
+                ShaderRegister = 0, // b0
+                RegisterSpace = 0,  // space0
+                Num32BitValues = 4  // Global, View, Object, Material indices
+            }
+        };
+
+        var rootSignatureDesc = new D3D12_ROOT_SIGNATURE_DESC1
+        {
+            NumParameters = RootSignatureLayout.ROOT_PARAMETER_COUNT,
+            pParameters = rootParameters,
+            NumStaticSamplers = 0,
+            pStaticSamplers = null,
+            Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
+                | D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED
+                | D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED
+        };
+
+        var versionedDesc = new D3D12_VERSIONED_ROOT_SIGNATURE_DESC
+        {
+            Version = D3D_ROOT_SIGNATURE_VERSION_1_1,
+            Desc_1_1 = rootSignatureDesc
+        };
+
+        using ComPtr<ID3DBlob> pSignature = default;
+        using ComPtr<ID3DBlob> pError = default;
+
+        var serializeResult = D3D12SerializeVersionedRootSignature(&versionedDesc, pSignature.GetAddressOf(), pError.GetAddressOf());
+        if (serializeResult.FAILED)
+        {
+            var errorMsg = pError.Get() != null ? Marshal.PtrToStringUTF8((nint)pError.Get()->GetBufferPointer()) : "Unknown error";
+            return Result.Failure($"Failed to serialize default root signature: {errorMsg}");
+        }
+
+        ID3D12RootSignature* pRootSignature = default;
+        ThrowIfFailed(_device.NativeDevice.Get()->CreateRootSignature(0, pSignature.Get()->GetBufferPointer(), pSignature.Get()->GetBufferSize(),
+            __uuidof(pRootSignature), (void**)&pRootSignature));
+
+        _defaultRootSignature.Attach(pRootSignature);
+
+        return Result.Success();
+    }
+
+    public void InitializeLibrary(string? filePath)
+    {
+        ID3D12PipelineLibrary1* pLibrary = default;
+
+        if (File.Exists(filePath))
+        {
+            var fileBytes = File.ReadAllBytes(filePath);
+            fixed (byte* pFileBytes = fileBytes)
+            {
+                ThrowIfFailed(_device.NativeDevice.Get()->CreatePipelineLibrary(pFileBytes, (nuint)fileBytes.Length, __uuidof(pLibrary), (void**)&pLibrary));
+            }
+        }
+        else
+        {
+            ThrowIfFailed(_device.NativeDevice.Get()->CreatePipelineLibrary(null, 0, __uuidof(pLibrary), (void**)&pLibrary));
+        }
+
+        _library.Attach(pLibrary);
+    }
+
+    public void SaveLibraryToDisk(string filePath)
+    {
+        var dir = Path.GetDirectoryName(filePath);
+        if (!Directory.Exists(dir))
+        {
+            throw new InvalidOperationException($"Directory does not exist: {dir}");
+        }
+
+        var size = _library.Get()->GetSerializedSize();
+        using var buffer = new UnsafeArray<byte>((int)size, Allocator.Persistent); // We use persistent Heap allocation instead of stack allocation to avoid stack overflow for large pipeline libraries.
+
+        ThrowIfFailed(_library.Get()->Serialize(buffer.GetUnsafePtr(), size));
+
+        using var fs = File.Open(filePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        fs.Write(buffer.AsSpan());
+    }
+
+    private static Result<CBufferInfo> ValidateReflectionData(ShaderReflectionData reflectionData)
+    {
+        if (reflectionData.ResourcesBindings.Count > RootSignatureLayout.ROOT_PARAMETER_COUNT)
+        {
+            return Result.Failure($"Shader uses more root parameters than supported ({RootSignatureLayout.ROOT_PARAMETER_COUNT}).");
+        }
+
+        if (reflectionData.ResourcesBindings.Count == 0)
+        {
+            return Result.Success(default(CBufferInfo));
+        }
+
+        var rootConstant = reflectionData.ResourcesBindings[0];
+        if (rootConstant.Type != ShaderInputType.ConstantBuffer)
+        {
+            return Result.Failure($"Root constant parameter must be a constant buffer.");
+        }
+
+        if (rootConstant.Size != sizeof(PushConstantsData))
+        {
+            return Result.Failure($"Root constant buffer size must be {sizeof(PushConstantsData)} bytes.");
+        }
+
+        var cbufferInfo = new CBufferInfo
+        {
+            Name = rootConstant.Name,
+            RegisterSlot = rootConstant.BindPoint,
+            RegisterSpace = rootConstant.Space,
+            SizeInBytes = rootConstant.Size,
+            Properties = rootConstant.Properties
+        };
+
+        return Result.Success(cbufferInfo);
+    }
+
+    private static D3D12_DEPTH_STENCIL_DESC BuildDepthStencil(ZTest ztest, ZWrite zwrite)
+    {
+        var depthEnabled = ztest != ZTest.Disabled;
+        var writeEnabled = zwrite == ZWrite.On;
+        var cmp = ztest.ToD3DCompare();
+        return D3D12Utility.D3D12_DEPTH_STENCIL_DESC_CREATE(depthEnabled, writeEnabled, cmp);
+    }
+
+    public Result<Key128<GraphicsPipeline>> CompilePSO(ref readonly GraphicsPSODescriptor descriptor, ref readonly GraphicsCompiledResult compiled)
+    {
+        static Result<CBufferInfo> ValidatePassReflectionData(ref readonly GraphicsCompiledResult compiled)
+        {
+            var msr = ValidateReflectionData(compiled.msResult.reflectionData);
+            if (msr.IsFailure)
+            {
+                return Result.Failure("Validation of mesh shader reflection data failed: " + msr.Message);
+            }
+
+            var psr = ValidateReflectionData(compiled.psResult.reflectionData);
+            if (psr.IsFailure)
+            {
+                return Result.Failure("Validation of pixel shader reflection data failed: " + psr.Message);
+            }
+
+            if (msr.Value.Properties != null
+                && msr.Value.SizeInBytes != psr.Value.SizeInBytes)
+            {
+                return Result.Failure("Mesh shader and pixel shader constant buffer layouts do not match.");
+            }
+
+            if (compiled.tsResult.IsCreated)
+            {
+                var tsr = ValidateReflectionData(compiled.tsResult.reflectionData);
+                if (tsr.IsFailure)
+                {
+                    return Result.Failure("Validation of task shader reflection data failed: " + tsr.Message);
+                }
+
+                if (tsr.Value.Properties != null
+                    && tsr.Value.SizeInBytes != psr.Value.SizeInBytes)
+                {
+                    return Result.Failure("Task shader and pixel shader constant buffer layouts do not match.");
+                }
+            }
+
+            // ts and ms may not use per material cbuffer at all, so we return the psr value.
+            return psr.Value;
+        }
+
+        if (descriptor.RtvFormats.Length > D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT)
+        {
+            return Result.Failure($"RTV format count exceeds the maximum supported render target count of {D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT}.");
+        }
+
+        var passPipelineKey = new PassPipelineHash(descriptor.RtvFormats, descriptor.DsvFormat);
+        var pipelineKey = RHIUtility.CreateGraphicsPipelineKey(descriptor.VariantKey, descriptor.PipelineOption, passPipelineKey);
+
+        if (!_pipelineCache.ContainsKey(pipelineKey))
+        {
+            //var result = ValidatePassReflectionData(in compiled);
+            //if (result.IsFailure)
+            //{
+            //    return Result.Failure(result.Message);
+            //}
+
+            var desc = new D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
+            {
+                pRootSignature = _defaultRootSignature.Get(),
+                MS = new D3D12_SHADER_BYTECODE(compiled.msResult.bytecode.GetUnsafePtr(), (nuint)compiled.msResult.bytecode.Count),
+                PS = new D3D12_SHADER_BYTECODE(compiled.psResult.bytecode.GetUnsafePtr(), (nuint)compiled.psResult.bytecode.Count),
+                PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+                SampleMask = UINT32_MAX,
+                SampleDesc = new DXGI_SAMPLE_DESC(1, 0),
+                NumRenderTargets = (uint)descriptor.RtvFormats.Length,
+                DSVFormat = descriptor.DsvFormat.ToDXGIFormat(),
+                DepthStencilState = BuildDepthStencil(descriptor.PipelineOption.ZTest, descriptor.PipelineOption.ZWrite),
+                NodeMask = 0,
+                Flags = D3D12_PIPELINE_STATE_FLAG_NONE,
+
+                BlendState = descriptor.PipelineOption.Blend switch
+                {
+                    Blend.Opaque => D3D12Utility.D3D12_BLEND_DESC_OPAQUE,
+                    Blend.Alpha => D3D12Utility.D3D12_BLEND_DESC_ALPHA_BLEND,
+                    Blend.Additive => D3D12Utility.D3D12_BLEND_DESC_ADDITIVE,
+                    Blend.Multiply => D3D12Utility.D3D12_BLEND_DESC_MULTIPLY,
+                    Blend.PremultipliedAlpha => D3D12Utility.D3D12_BLEND_DESC_PREMULTIPLIED,
+                    _ => D3D12Utility.D3D12_BLEND_DESC_OPAQUE
+                },
+                RasterizerState = descriptor.PipelineOption.Cull switch
+                {
+                    Cull.Off => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE,
+                    Cull.Front => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_CLOCKWISE,
+                    Cull.Back => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_COUNTER_CLOCKWISE,
+                    _ => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE
+                },
+            };
+
+            if (compiled.tsResult.IsCreated)
+            {
+                desc.AS = new D3D12_SHADER_BYTECODE(compiled.tsResult.bytecode.GetUnsafePtr(), (nuint)compiled.tsResult.bytecode.Count);
+            }
+
+            for (var i = 0; i < descriptor.RtvFormats.Length; i++)
+            {
+                desc.RTVFormats[i] = descriptor.RtvFormats[i].ToDXGIFormat();
+                desc.BlendState.RenderTarget[i].RenderTargetWriteMask = (byte)((int)descriptor.PipelineOption.ColorMask & 0x0F);
+            }
+
+            var meshStream = new CD3DX12_PIPELINE_MESH_STATE_STREAM(in desc);
+            var streamDesc = new D3D12_PIPELINE_STATE_STREAM_DESC
+            {
+                pPipelineStateSubobjectStream = &meshStream,
+                SizeInBytes = (nuint)sizeof(CD3DX12_PIPELINE_MESH_STATE_STREAM)
+            };
+
+            ID3D12PipelineState* pPipelineState = default;
+
+            var pKeyStr = stackalloc char[33]; // 32 for 128 bits key + 1 for null terminator
+            var keySpan = new Span<char>(pKeyStr, 33);
+            if (!pipelineKey.TryGetString(keySpan))
+            {
+                return Result.Failure("Failed to convert pipeline key to string.");
+            }
+
+            var hr = _library.Get()->LoadPipeline(pKeyStr, &streamDesc, __uuidof(pPipelineState), (void**)&pPipelineState);
+            if (hr == E.E_INVALIDARG)
+            {
+                // Pipeline not found in the library, create a new one.
+                ThrowIfFailed(_device.NativeDevice.Get()->CreatePipelineState(&streamDesc, __uuidof(pPipelineState), (void**)&pPipelineState));
+                ThrowIfFailed(_library.Get()->StorePipeline(pKeyStr, pPipelineState));
+            }
+            else
+            {
+                ThrowIfFailed(hr);
+            }
+
+            D3D12PipelineState pso = default;
+            pso.shaderVariant = descriptor.VariantKey;
+            pso.psoDesc = desc;
+            pso.pso.Attach(pPipelineState);
+
+            _pipelineCache[pipelineKey] = pso;
+        }
+
+        return pipelineKey;
+    }
+
+    public bool HasPipeline(Key128<GraphicsPipeline> key)
+    {
+        return _pipelineCache.ContainsKey(key);
+    }
+
+    public Result<SharedPtr<ID3D12PipelineState>, Error> GetGraphicsPSO(Key128<GraphicsPipeline> key)
+    {
+        if (_pipelineCache.TryGetValue(key, out var cacheEntry))
+        {
+            return cacheEntry.pso.Share();
+        }
+
+        return Error.NotFound;
+    }
+
+    public void Dispose()
+    {
+        foreach (var kvp in _pipelineCache)
+        {
+            kvp.Value.Dispose();
+        }
+
+        _pipelineCache.Clear();
+
+        _defaultRootSignature.Dispose();
+        _library.Dispose();
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12RenderDevice.cs

@@ -0,0 +1,187 @@
+using Ghost.Core.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+using static TerraFX.Aliases.D3D_Alias;
+using static TerraFX.Aliases.D3D12_Alias;
+using static TerraFX.Aliases.DXGI_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of the render device interface
+/// </summary>
+internal unsafe class D3D12RenderDevice : IRenderDevice
+{
+    private UniquePtr<ID3D12Device14> _device;
+    private UniquePtr<IDXGIFactory7> _dxgiFactory;
+    private UniquePtr<IDXGIAdapter1> _adapter;
+
+    private readonly D3D12CommandQueue _graphicsQueue;
+    private readonly D3D12CommandQueue _computeQueue;
+    private readonly D3D12CommandQueue _copyQueue;
+
+    private bool _disposed;
+
+    public ICommandQueue GraphicsQueue => _graphicsQueue;
+    public ICommandQueue ComputeQueue => _computeQueue;
+    public ICommandQueue CopyQueue => _copyQueue;
+
+    public FeatureSupport FeatureSupport
+    {
+        get;
+    }
+
+    public SharedPtr<IDXGIFactory7> DXGIFactory => _dxgiFactory.Share();
+    public SharedPtr<ID3D12Device14> NativeDevice => _device.Share();
+    public SharedPtr<IDXGIAdapter1> Adapter => _adapter.Share();
+    public SharedPtr<ID3D12CommandQueue> NativeGraphicsQueue => _graphicsQueue.NativeQueue;
+    public SharedPtr<ID3D12CommandQueue> NativeComputeQueue => _computeQueue.NativeQueue;
+    public SharedPtr<ID3D12CommandQueue> NativeCopyQueue => _copyQueue.NativeQueue;
+
+    public D3D12RenderDevice()
+    {
+        IDXGIFactory7* pFactory = default;
+#if DEBUG
+        ThrowIfFailed(CreateDXGIFactory2(TRUE, __uuidof(pFactory), (void**)&pFactory));
+#else
+        ThrowIfFailed(CreateDXGIFactory2(FALSE, __uuidof(pFactory), (void**)&pFactory));
+#endif
+
+        _dxgiFactory.Attach(pFactory);
+
+        InitializeDevice();
+
+        _graphicsQueue = new D3D12CommandQueue(_device.Get(), CommandQueueType.Graphics);
+        _computeQueue = new D3D12CommandQueue(_device.Get(), CommandQueueType.Compute);
+        _copyQueue = new D3D12CommandQueue(_device.Get(), CommandQueueType.Copy);
+
+        FeatureSupport = GetFeatureSupport();
+    }
+
+    ~D3D12RenderDevice()
+    {
+        Dispose();
+    }
+
+    private void InitializeDevice()
+    {
+        ID3D12Device14* pDevice = default;
+        IDXGIAdapter1* pAdapter = default;
+
+        for (uint adapterIndex = 0;
+            _dxgiFactory.Get()->EnumAdapterByGpuPreference(adapterIndex, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, __uuidof(pAdapter), (void**)&pAdapter).SUCCEEDED;
+            adapterIndex++)
+        {
+            DXGI_ADAPTER_DESC1 desc = default;
+            pAdapter->GetDesc1(&desc);
+
+            // Don't select the Basic Render Driver adapter.
+            if (desc.Flags.HasFlag(DXGI_ADAPTER_FLAG_SOFTWARE))
+            {
+                goto NEXT_ITERATION;
+            }
+
+            if (D3D12CreateDevice((IUnknown*)pAdapter, D3D_FEATURE_LEVEL_12_0, __uuidof(pDevice), (void**)&pDevice).SUCCEEDED)
+            {
+                _adapter.Attach(pAdapter);
+                break;
+            }
+
+        NEXT_ITERATION:
+            pAdapter->Release();
+        }
+
+        if (pDevice == null)
+        {
+            pAdapter->Release(); // Dispose the last adapter we tried.
+            throw new PlatformNotSupportedException("Cannot create ID3D12Device with feature level 12.0");
+        }
+
+        _device.Attach(pDevice);
+    }
+
+    private FeatureSupport GetFeatureSupport()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        FeatureSupport support = FeatureSupport.None;
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS options = default;
+        if (_device.Get()->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &options, (uint)sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS)).SUCCEEDED)
+        {
+            if (options.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_3)
+            {
+                support |= FeatureSupport.BindlessResources;
+            }
+
+            if (options.ResourceHeapTier == D3D12_RESOURCE_HEAP_TIER.D3D12_RESOURCE_HEAP_TIER_2)
+            {
+                support |= FeatureSupport.AliasBuffersAndTextures;
+            }
+        }
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS5 options5 = default;
+        if (_device.Get()->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &options5, (uint)sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS5)).SUCCEEDED)
+        {
+            if (options5.RaytracingTier != D3D12_RAYTRACING_TIER_NOT_SUPPORTED)
+            {
+                support |= FeatureSupport.RayTracing;
+            }
+        }
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS6 options6 = default;
+        if (_device.Get()->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &options6, (uint)sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS6)).SUCCEEDED)
+        {
+            if (options6.VariableShadingRateTier != D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED)
+            {
+                support |= FeatureSupport.VariableRateShading;
+            }
+        }
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7 = default;
+        if (_device.Get()->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options7, (uint)sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS7)).SUCCEEDED)
+        {
+            if (options7.MeshShaderTier != D3D12_MESH_SHADER_TIER_NOT_SUPPORTED)
+            {
+                support |= FeatureSupport.MeshShaders;
+            }
+
+            if (options7.SamplerFeedbackTier != D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED)
+            {
+                support |= FeatureSupport.SamplerFeedback;
+            }
+        }
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS21 options9 = default;
+        if (_device.Get()->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS21, &options9, (uint)sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS8)).SUCCEEDED)
+        {
+            if (options9.WorkGraphsTier != D3D12_WORK_GRAPHS_TIER.D3D12_WORK_GRAPHS_TIER_NOT_SUPPORTED)
+            {
+                support |= FeatureSupport.WorkGraphs;
+            }
+        }
+
+        return support;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _graphicsQueue.Dispose();
+        _computeQueue.Dispose();
+        _copyQueue.Dispose();
+
+        _device.Dispose();
+        _dxgiFactory.Dispose();
+        _adapter.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12Renderer.cs

@@ -0,0 +1,139 @@
+using Ghost.Core;
+using Ghost.Graphics.RHI;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.RenderPasses;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.RenderGraphModule;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of the renderer interface using RHI abstractions
+/// </summary>
+internal class D3D12Renderer : IRenderer
+{
+    private readonly D3D12GraphicsEngine _graphicsEngine;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+
+    private readonly ICommandBuffer _commandBuffer;
+    private readonly RenderGraph _renderGraph;
+
+    private uint _frameIndex;
+    private bool _disposed;
+
+    // NOTE: Testing only.
+    private readonly MeshRenderPass _pass;
+
+    public IRenderOutput? RenderOutput
+    {
+        get; set;
+    }
+
+    // TODO: Add render graph support
+
+    public D3D12Renderer(D3D12GraphicsEngine graphicsEngine, D3D12ResourceDatabase resourceDatabase)
+    {
+        _graphicsEngine = graphicsEngine;
+        _resourceDatabase = resourceDatabase;
+
+        _commandBuffer = _graphicsEngine.CreateCommandBuffer(CommandBufferType.Graphics);
+        _renderGraph = new RenderGraph(_graphicsEngine);
+
+        // NOTE: Testing only.
+        _pass = new();
+    }
+
+    ~D3D12Renderer()
+    {
+        Dispose();
+    }
+
+    public Result Render(ICommandAllocator commandAllocator)
+    {
+        if (RenderOutput is null)
+        {
+            return Result.Failure("Render target strategy is not set.");
+        }
+
+        var target = RenderOutput.GetRenderTarget();
+        if (target.IsInvalid)
+        {
+            return Result.Failure("Render target is invalid.");
+        }
+
+        _commandBuffer.Begin(commandAllocator);
+        RenderOutput.BeginRender(_commandBuffer);
+
+        // NOTE: Temporary solution: render directly to the swap chain back buffer if available.
+        // HACK: This is hard coded for testing purposes only.
+
+        var error = RenderScene(target, RenderOutput.Viewport, RenderOutput.Scissor);
+        if (error != Error.None)
+        {
+            _commandBuffer.End();
+            return Result.Failure(error);
+        }
+
+        RenderOutput.EndRender(_commandBuffer);
+        var r = _commandBuffer.End();
+        if (r.IsFailure)
+        {
+            return r;
+        }
+
+        _graphicsEngine.Device.GraphicsQueue.Submit(_commandBuffer);
+        RenderOutput.Present();
+
+        return Result.Success();
+    }
+
+    // TODO: A proper render graph integration.
+    private Error RenderScene(Handle<Texture> target, ViewportDesc viewport, RectDesc rect)
+    {
+        // NOTE: Testing only.
+        var ctx = new RenderingContext(_graphicsEngine, _commandBuffer);
+        if (_frameIndex == 0)
+        {
+            _pass.Initialize(ref ctx);
+        }
+
+        //_commandBuffer.BeginRenderPass(rtDesc, depthDesc, false);
+        _commandBuffer.SetViewport(viewport);
+        _commandBuffer.SetScissorRect(rect);
+
+        _renderGraph.Reset();
+
+        var backBuffer = _renderGraph.ImportTexture(target, "Back Buffer");
+        _pass.Build(_renderGraph, backBuffer);
+
+        // Create view state from viewport
+        var viewState = new ViewState((uint)viewport.Width, (uint)viewport.Height);
+
+        // Compile with view state
+        _renderGraph.Compile(in viewState);
+        _renderGraph.Execute(_commandBuffer);
+
+        //_commandBuffer.EndRenderPass();
+        _frameIndex++;
+
+        return Error.None;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        // NOTE: Testing only.
+        _pass.Cleanup(_resourceDatabase);
+        _renderGraph.Dispose();
+
+        _commandBuffer.Dispose();
+
+        _disposed = true;
+
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12ResourceAllocator.cs

@@ -0,0 +1,997 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Core.Utilities;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Aliases.D3D12_Alias;
+using static TerraFX.Aliases.D3D12MA_Alias;
+using static TerraFX.Aliases.DXGI_Alias;
+using static TerraFX.Interop.DirectX.D3D12MemAlloc;
+
+namespace Ghost.Graphics.D3D12;
+
+internal sealed unsafe partial class D3D12ResourceAllocator
+{
+    // NOTE: _MAX_BYTES may not be accurate, we need to verify it with feature level checks.
+    private const uint _MAX_BYTES = D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM * 1024u * 1024u;
+    private const uint _MAX_TEXTURE2D_DIMENSION = 16384u;
+    private const uint _MAX_TEXTURE3D_DIMENSION = 2048u;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void CheckBufferSize(ulong sizeInBytes)
+    {
+        if (sizeInBytes > _MAX_BYTES)
+        {
+            throw new InvalidOperationException($"ERROR: Resource size too large for DirectX 12 (size {sizeInBytes})");
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void CheckTexture2DSize(uint width, uint height)
+    {
+        if (width > _MAX_TEXTURE2D_DIMENSION || height > _MAX_TEXTURE2D_DIMENSION)
+        {
+            throw new InvalidOperationException($"ERROR: Texture size too large for DirectX 12 (width {width}, height {height})");
+        }
+    }
+
+    private static D3D12_SHADER_RESOURCE_VIEW_DESC CreateTextureSrvDesc(ID3D12Resource* pResource, uint mipLevels, uint arraySize, bool isCubeMap)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var srvDesc = new D3D12_SHADER_RESOURCE_VIEW_DESC
+        {
+            Format = resourceDesc.Format,
+            Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING
+        };
+
+        switch (resourceDesc.Dimension)
+        {
+            case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+                if (resourceDesc.DepthOrArraySize > 1)
+                {
+                    srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
+                    srvDesc.Texture1DArray = new D3D12_TEX1D_ARRAY_SRV
+                    {
+                        MipLevels = mipLevels,
+                        ArraySize = arraySize,
+                    };
+                }
+                else
+                {
+                    srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
+                    srvDesc.Texture1D = new D3D12_TEX1D_SRV
+                    {
+                        MipLevels = mipLevels,
+                    };
+                }
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+                if (resourceDesc.DepthOrArraySize > 1)
+                {
+                    if (isCubeMap)
+                    {
+                        srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
+                        srvDesc.TextureCubeArray = new D3D12_TEXCUBE_ARRAY_SRV
+                        {
+                            MipLevels = mipLevels,
+                            NumCubes = arraySize / 6,
+                        };
+                    }
+                    else
+                    {
+                        srvDesc.ViewDimension = resourceDesc.SampleDesc.Count > 1 ? D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY : D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+                        srvDesc.Texture2DArray = new D3D12_TEX2D_ARRAY_SRV
+                        {
+                            MipLevels = mipLevels,
+                            ArraySize = arraySize,
+                        };
+                    }
+                }
+                else
+                {
+                    if (isCubeMap)
+                    {
+                        srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+                        srvDesc.TextureCube = new D3D12_TEXCUBE_SRV
+                        {
+                            MipLevels = mipLevels,
+                        };
+                    }
+                    else
+                    {
+                        srvDesc.ViewDimension = resourceDesc.SampleDesc.Count > 1 ? D3D12_SRV_DIMENSION_TEXTURE2DMS : D3D12_SRV_DIMENSION_TEXTURE2D;
+                        srvDesc.Texture2D = new D3D12_TEX2D_SRV
+                        {
+                            MipLevels = mipLevels,
+                        };
+                    }
+                }
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+                srvDesc.Texture3D = new D3D12_TEX3D_SRV
+                {
+                    MipLevels = mipLevels,
+                };
+                break;
+            default:
+                throw new ArgumentException($"Unsupported texture dimension for SRV: {resourceDesc.Dimension}");
+        }
+
+        return srvDesc;
+    }
+
+    private static D3D12_SHADER_RESOURCE_VIEW_DESC CreateBufferSrvDesc(ID3D12Resource* pResource, uint stride, bool isRaw)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var srvDesc = new D3D12_SHADER_RESOURCE_VIEW_DESC
+        {
+            ViewDimension = D3D12_SRV_DIMENSION_BUFFER,
+            Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING
+        };
+
+        if (isRaw)
+        {
+            srvDesc.Format = DXGI_FORMAT_R32_TYPELESS;
+            srvDesc.Buffer.FirstElement = 0;
+            srvDesc.Buffer.NumElements = (uint)(resourceDesc.Width / 4u);
+            srvDesc.Buffer.StructureByteStride = 0;
+            srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
+        }
+        else // Assumes Structured
+        {
+            srvDesc.Format = resourceDesc.Format;
+            srvDesc.Buffer.FirstElement = 0;
+            srvDesc.Buffer.NumElements = (uint)(resourceDesc.Width / stride);
+            srvDesc.Buffer.StructureByteStride = stride;
+            srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
+        }
+
+        return srvDesc;
+    }
+
+    private static D3D12_RENDER_TARGET_VIEW_DESC CreateRtvDesc(ID3D12Resource* pResource, uint mipSlice = 0, uint firstArraySlice = 0, uint planeSlice = 0)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var rtvDesc = new D3D12_RENDER_TARGET_VIEW_DESC();
+
+        switch (resourceDesc.Dimension)
+        {
+            case D3D12_RESOURCE_DIMENSION_BUFFER:
+                rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_BUFFER;
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+                rtvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_RTV_DIMENSION_TEXTURE1DARRAY : D3D12_RTV_DIMENSION_TEXTURE1D;
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+                if (resourceDesc.SampleDesc.Count > 1)
+                {
+                    rtvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY : D3D12_RTV_DIMENSION_TEXTURE2DMS;
+                }
+                else
+                {
+                    rtvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DARRAY : D3D12_RTV_DIMENSION_TEXTURE2D;
+                }
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+                rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
+                break;
+
+            default:
+                throw new ArgumentException($"Unsupported texture dimension for SRV: {resourceDesc.Dimension}");
+        }
+
+        rtvDesc.Format = resourceDesc.Format;
+
+        var isArray =
+            rtvDesc.ViewDimension == D3D12_RTV_DIMENSION_TEXTURE2DARRAY ||
+            rtvDesc.ViewDimension == D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
+
+        var arraySize = 1u;
+        if (isArray)
+        {
+            arraySize = resourceDesc.ArraySize() - firstArraySlice;
+        }
+
+        switch (rtvDesc.ViewDimension)
+        {
+            case D3D12_RTV_DIMENSION_BUFFER:
+                rtvDesc.Buffer.FirstElement = firstArraySlice;
+                rtvDesc.Buffer.NumElements = arraySize;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE1D:
+                rtvDesc.Texture1D.MipSlice = mipSlice;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE1DARRAY:
+                rtvDesc.Texture1DArray.MipSlice = mipSlice;
+                rtvDesc.Texture1DArray.FirstArraySlice = firstArraySlice;
+                rtvDesc.Texture1DArray.ArraySize = arraySize;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE2D:
+                rtvDesc.Texture2D.MipSlice = mipSlice;
+                rtvDesc.Texture2D.PlaneSlice = planeSlice;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE2DARRAY:
+                rtvDesc.Texture2DArray.MipSlice = mipSlice;
+                rtvDesc.Texture2DArray.FirstArraySlice = firstArraySlice;
+                rtvDesc.Texture2DArray.ArraySize = arraySize;
+                rtvDesc.Texture2DArray.PlaneSlice = planeSlice;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE2DMS:
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY:
+                rtvDesc.Texture2DMSArray.FirstArraySlice = firstArraySlice;
+                rtvDesc.Texture2DMSArray.ArraySize = arraySize;
+                break;
+
+            case D3D12_RTV_DIMENSION_TEXTURE3D:
+                rtvDesc.Texture3D.MipSlice = mipSlice;
+                rtvDesc.Texture3D.FirstWSlice = firstArraySlice;
+                rtvDesc.Texture3D.WSize = arraySize;
+                break;
+
+            default:
+                throw new ArgumentException($"Unsupported RTV dimension: {rtvDesc.ViewDimension}");
+        }
+
+        return rtvDesc;
+    }
+
+    private static D3D12_DEPTH_STENCIL_VIEW_DESC CreateDsvDesc(ID3D12Resource* pResource, uint mipSlice = 0, uint firstArraySlice = 0, D3D12_DSV_FLAGS flags = D3D12_DSV_FLAG_NONE)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var dsvDesc = new D3D12_DEPTH_STENCIL_VIEW_DESC
+        {
+            Flags = flags,
+        };
+
+        switch (resourceDesc.Dimension)
+        {
+            case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+                dsvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_DSV_DIMENSION_TEXTURE1DARRAY : D3D12_DSV_DIMENSION_TEXTURE1D;
+                break;
+            case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+                if (resourceDesc.SampleDesc.Count > 1)
+                {
+                    dsvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY : D3D12_DSV_DIMENSION_TEXTURE2DMS;
+                }
+                else
+                {
+                    dsvDesc.ViewDimension = resourceDesc.DepthOrArraySize > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DARRAY : D3D12_DSV_DIMENSION_TEXTURE2D;
+                }
+                break;
+        }
+
+        dsvDesc.Format = resourceDesc.Format;
+
+        var isArray =
+            dsvDesc.ViewDimension == D3D12_DSV_DIMENSION_TEXTURE2DARRAY ||
+            dsvDesc.ViewDimension == D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
+
+        var arraySize = 1u;
+        if (isArray)
+        {
+            arraySize = resourceDesc.ArraySize() - firstArraySlice;
+        }
+
+        switch (dsvDesc.ViewDimension)
+        {
+            case D3D12_DSV_DIMENSION_TEXTURE1D:
+                dsvDesc.Texture1D.MipSlice = mipSlice;
+                break;
+            case D3D12_DSV_DIMENSION_TEXTURE1DARRAY:
+                dsvDesc.Texture1DArray.MipSlice = mipSlice;
+                dsvDesc.Texture1DArray.FirstArraySlice = firstArraySlice;
+                dsvDesc.Texture1DArray.ArraySize = arraySize;
+                break;
+            case D3D12_DSV_DIMENSION_TEXTURE2D:
+                dsvDesc.Texture2D.MipSlice = mipSlice;
+                break;
+            case D3D12_DSV_DIMENSION_TEXTURE2DARRAY:
+                dsvDesc.Texture2DArray.MipSlice = mipSlice;
+                dsvDesc.Texture2DArray.FirstArraySlice = firstArraySlice;
+                dsvDesc.Texture2DArray.ArraySize = arraySize;
+                break;
+            case D3D12_DSV_DIMENSION_TEXTURE2DMS:
+                break;
+            case D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY:
+                dsvDesc.Texture2DMSArray.FirstArraySlice = firstArraySlice;
+                dsvDesc.Texture2DMSArray.ArraySize = arraySize;
+                break;
+            default:
+                break;
+        }
+
+        return dsvDesc;
+    }
+
+    private static D3D12_UNORDERED_ACCESS_VIEW_DESC CreateTextureUavDesc(ID3D12Resource* pResource, uint mipSlice = 0, uint firstArraySlice = 0, uint planeSlice = 0)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var uavDesc = new D3D12_UNORDERED_ACCESS_VIEW_DESC
+        {
+            Format = resourceDesc.Format
+        };
+
+        switch (resourceDesc.Dimension)
+        {
+            case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+                if (resourceDesc.DepthOrArraySize > 1)
+                {
+                    uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
+                    uavDesc.Texture1DArray = new D3D12_TEX1D_ARRAY_UAV
+                    {
+                        MipSlice = mipSlice,
+                        FirstArraySlice = firstArraySlice,
+                        ArraySize = resourceDesc.ArraySize() - firstArraySlice
+                    };
+                }
+                else
+                {
+                    uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1D;
+                    uavDesc.Texture1D = new D3D12_TEX1D_UAV
+                    {
+                        MipSlice = mipSlice
+                    };
+                }
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+                if (resourceDesc.DepthOrArraySize > 1)
+                {
+                    uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+                    uavDesc.Texture2DArray = new D3D12_TEX2D_ARRAY_UAV
+                    {
+                        MipSlice = mipSlice,
+                        FirstArraySlice = firstArraySlice,
+                        ArraySize = resourceDesc.ArraySize() - firstArraySlice,
+                        PlaneSlice = planeSlice
+                    };
+                }
+                else
+                {
+                    uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+                    uavDesc.Texture2D = new D3D12_TEX2D_UAV
+                    {
+                        MipSlice = mipSlice,
+                        PlaneSlice = planeSlice
+                    };
+                }
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+                uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
+                uavDesc.Texture3D = new D3D12_TEX3D_UAV
+                {
+                    MipSlice = mipSlice,
+                    FirstWSlice = firstArraySlice,
+                    WSize = resourceDesc.Depth() - firstArraySlice
+                };
+                break;
+
+            case D3D12_RESOURCE_DIMENSION_BUFFER:
+                uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+                uavDesc.Buffer = new D3D12_BUFFER_UAV
+                {
+                    FirstElement = 0,
+                    NumElements = (uint)(resourceDesc.Width / 4), // Assuming R32_TYPELESS RAW
+                    StructureByteStride = 0,
+                    Flags = D3D12_BUFFER_UAV_FLAG_RAW
+                };
+                break;
+
+            default:
+                throw new ArgumentException($"Unsupported texture dimension for UAV: {resourceDesc.Dimension}");
+        }
+
+        return uavDesc;
+    }
+
+    private static D3D12_UNORDERED_ACCESS_VIEW_DESC CreateBufferUavDesc(ID3D12Resource* pResource, uint stride, bool isRaw)
+    {
+        var resourceDesc = pResource->GetDesc();
+        var uavDesc = new D3D12_UNORDERED_ACCESS_VIEW_DESC
+        {
+            ViewDimension = D3D12_UAV_DIMENSION_BUFFER,
+        };
+
+        if (isRaw)
+        {
+            uavDesc.Format = DXGI_FORMAT_R32_TYPELESS;
+            uavDesc.Buffer.FirstElement = 0;
+            uavDesc.Buffer.NumElements = (uint)(resourceDesc.Width / 4u);
+            uavDesc.Buffer.StructureByteStride = 0;
+            uavDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
+        }
+        else // Assumes Structured
+        {
+            uavDesc.Format = resourceDesc.Format;
+            uavDesc.Buffer.FirstElement = 0;
+            uavDesc.Buffer.NumElements = (uint)(resourceDesc.Width / stride);
+            uavDesc.Buffer.StructureByteStride = stride;
+            uavDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
+        }
+
+        return uavDesc;
+    }
+
+    private static D3D12_HEAP_TYPE ConvertMemoryType(ResourceMemoryType memoryType)
+    {
+        return memoryType switch
+        {
+            ResourceMemoryType.Default => D3D12_HEAP_TYPE_DEFAULT,
+            ResourceMemoryType.Upload => D3D12_HEAP_TYPE_UPLOAD,
+            ResourceMemoryType.Readback => D3D12_HEAP_TYPE_READBACK,
+            _ => throw new ArgumentException($"Unsupported memory type: {memoryType}")
+        };
+    }
+}
+
+internal sealed unsafe partial class D3D12ResourceAllocator : IResourceAllocator
+{
+    private const uint _UPLOAD_BATCH_SIZE = 64 * 1024 * 1024; // 64 MB
+    private const uint _MAX_RESOURCE_SIZE_TO_FIT_IN_UPLOAD_BATCH = 16 * 1024 * 1024; // 16 MB
+
+    private UniquePtr<D3D12MA_Allocator> _d3d12MA;
+
+    private readonly IFenceSynchronizer _fenceSynchronizer;
+    private readonly D3D12RenderDevice _device;
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+    private readonly D3D12PipelineLibrary _pipelineLibrary;
+
+    private UnsafeQueue<Handle<GPUResource>> _tempResources;
+
+    private readonly Handle<GraphicsBuffer> _uploadBatch;
+    private ulong _uploadBatchOffset;
+
+    private bool _disposed;
+
+    public D3D12ResourceAllocator(
+        IFenceSynchronizer fenceSynchronizer,
+        D3D12RenderDevice device,
+        D3D12DescriptorAllocator descriptorAllocator,
+        D3D12ResourceDatabase resourceDatabase,
+        D3D12PipelineLibrary pipelineLibrary)
+    {
+        var desc = new D3D12MA_ALLOCATOR_DESC
+        {
+            pAdapter = (IDXGIAdapter*)device.Adapter.Get(),
+            pDevice = (ID3D12Device*)device.NativeDevice.Get(),
+            Flags = D3D12MA_ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED | D3D12MA_ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED,
+        };
+
+        D3D12MA_Allocator* pAllocator = default;
+        ThrowIfFailed(D3D12MA_CreateAllocator(&desc, &pAllocator));
+        _d3d12MA.Attach(pAllocator);
+
+        _fenceSynchronizer = fenceSynchronizer;
+        _device = device;
+        _descriptorAllocator = descriptorAllocator;
+        _resourceDatabase = resourceDatabase;
+        _pipelineLibrary = pipelineLibrary;
+
+        _tempResources = new UnsafeQueue<Handle<GPUResource>>(64, Allocator.Persistent);
+
+        // Create an upload batch
+        var uploadDesc = new BufferDesc
+        {
+            Size = _UPLOAD_BATCH_SIZE,
+            Usage = BufferUsage.Upload,
+            MemoryType = ResourceMemoryType.Upload,
+        };
+
+        _uploadBatch = CreateBuffer(in uploadDesc, "D3D12ResourceAllocator_UploadBatch");
+        _uploadBatchOffset = 0;
+    }
+
+    ~D3D12ResourceAllocator()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private Handle<GPUResource> TrackAllocation(D3D12MA_Allocation* allocation, ResourceBarrierData barrierData, ResourceViewGroup resourceDescriptor, ResourceDesc desc, string name, bool isTemp)
+    {
+        var handle = _resourceDatabase.AddAllocation(allocation, _fenceSynchronizer.CPUFenceValue, barrierData, resourceDescriptor, desc, name);
+
+        if (isTemp)
+        {
+            _tempResources.Enqueue(handle);
+        }
+
+        return handle;
+    }
+
+    private HRESULT CreateResource(D3D12MA_ALLOCATION_DESC* pAllocationDesc, D3D12_RESOURCE_DESC* pResourceDesc, D3D12_RESOURCE_STATES initialState, CreationOptions options, Guid* riid, void** ppv)
+    {
+        HRESULT hr;
+
+        if (options.AllocationType == ResourceAllocationType.Suballocation)
+        {
+            // pAllocation should be the render graph Heap. ppvResource should be the out resource.
+            var result = _resourceDatabase.GetResourceRecord(options.Heap);
+            if (result.IsFailure)
+            {
+                return E.E_NOTFOUND;
+            }
+
+            hr = _d3d12MA.Get()->CreateAliasingResource(result.Value.resource.allocation.Get(), options.Offset, pResourceDesc, initialState, null, riid, ppv);
+        }
+        else
+        {
+            var iid_null = IID.IID_NULL;
+            hr = _d3d12MA.Get()->CreateResource(pAllocationDesc, pResourceDesc, initialState, null, (D3D12MA_Allocation**)ppv, &iid_null, null);
+        }
+
+        return hr;
+    }
+
+    public ResourceSizeInfo GetSizeInfo(ResourceDesc desc)
+    {
+        D3D12_RESOURCE_DESC d3d12Desc;
+        if (desc.Type == ResourceType.Texture)
+        {
+            d3d12Desc = desc.TextureDescription.ToD3D12ResourceDesc();
+        }
+        else
+        {
+            d3d12Desc = desc.BufferDescription.ToD3D12ResourceDesc();
+        }
+
+        var info = _device.NativeDevice.Get()->GetResourceAllocationInfo(0, 1, &d3d12Desc);
+        return new ResourceSizeInfo
+        {
+            Size = info.SizeInBytes,
+            Alignment = info.Alignment
+        };
+    }
+
+    public Handle<GPUResource> Allocate(ref readonly AllocationDesc desc, string name)
+    {
+        var allocDesc = new D3D12MA_ALLOCATION_DESC
+        {
+            HeapType = desc.HeapType switch
+            {
+                HeapType.Default => D3D12_HEAP_TYPE_DEFAULT,
+                HeapType.Upload => D3D12_HEAP_TYPE_UPLOAD,
+                HeapType.Readback => D3D12_HEAP_TYPE_READBACK,
+                _ => D3D12_HEAP_TYPE_DEFAULT
+            },
+            Flags = D3D12MA_ALLOCATION_FLAG_COMMITTED,
+            ExtraHeapFlags = desc.HeapFlags switch
+            {
+                HeapFlags.None => D3D12_HEAP_FLAG_NONE,
+                HeapFlags.AllowBuffers => D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS,
+                HeapFlags.AllowTextures => D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES,
+                HeapFlags.AllowRTAndDS => D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES,
+                HeapFlags.AlowBufferAndTexture => D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES,
+                _ => D3D12_HEAP_FLAG_NONE
+            }
+        };
+
+        // SizeInBytes must be aligned to 64KB for committed resources
+        var allocInfo = new D3D12_RESOURCE_ALLOCATION_INFO
+        {
+            SizeInBytes = desc.Size + 65535 & ~65535u,
+            Alignment = desc.Alignment
+        };
+
+        D3D12MA_Allocation* alloc = default;
+        if (_d3d12MA.Get()->AllocateMemory(&allocDesc, &allocInfo, &alloc).FAILED)
+        {
+            return Handle<GPUResource>.Invalid;
+        }
+
+        var barrierData = new ResourceBarrierData
+        {
+            access = BarrierAccess.NoAccess,
+            layout = BarrierLayout.Common,
+            sync = BarrierSync.None
+        };
+
+        return TrackAllocation(alloc, barrierData, ResourceViewGroup.Invalid, default, name, false);
+    }
+
+    public Handle<Texture> CreateTexture(ref readonly TextureDesc desc, string name, CreationOptions options = default)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        CheckTexture2DSize(desc.Width, desc.Height);
+
+        var resourceDesc = desc.ToD3D12ResourceDesc();
+        var allocationDesc = new D3D12MA_ALLOCATION_DESC
+        {
+            HeapType = D3D12_HEAP_TYPE_DEFAULT,
+            Flags = D3D12MA_ALLOCATION_FLAG_NONE
+        };
+
+        var isSubAllocation = options.AllocationType == ResourceAllocationType.Suballocation;
+        D3D12MA_Allocation* pAllocation = default;
+        ID3D12Resource* pResource = default;
+        HRESULT hr;
+
+        if (isSubAllocation)
+        {
+            hr = CreateResource(&allocationDesc, &resourceDesc, D3D12_RESOURCE_STATE_COMMON, options, __uuidof(pResource), (void**)&pResource);
+        }
+        else
+        {
+            hr = CreateResource(&allocationDesc, &resourceDesc, D3D12_RESOURCE_STATE_COMMON, options, null, (void**)&pAllocation);
+            pResource = pAllocation->GetResource();
+        }
+
+        if (hr.FAILED)
+        {
+#if DEBUG
+            ThrowIfFailed(hr);
+#endif
+            return Handle<Texture>.Invalid;
+        }
+
+        var isTemp = options.AllocationType == ResourceAllocationType.Temporary;
+        var resourceDescriptor = ResourceViewGroup.Invalid;
+        if (desc.Usage.HasFlag(TextureUsage.ShaderResource))
+        {
+            resourceDescriptor.srv = _descriptorAllocator.AllocateCbvSrvUav();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.srv);
+
+            var isCubeMap = desc.Dimension == TextureDimension.TextureCube || desc.Dimension == TextureDimension.TextureCubeArray;
+            var srvDesc = CreateTextureSrvDesc(pResource, resourceDesc.MipLevels, resourceDesc.DepthOrArraySize, isCubeMap);
+
+            _device.NativeDevice.Get()->CreateShaderResourceView(pResource, &srvDesc, cpuHandle);
+            _descriptorAllocator.CopyToShaderVisible(resourceDescriptor.srv);
+        }
+
+        if (desc.Usage.HasFlag(TextureUsage.RenderTarget))
+        {
+            resourceDescriptor.rtv = _descriptorAllocator.AllocateRTV();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.rtv);
+            var rtvDesc = CreateRtvDesc(pResource);
+
+            _device.NativeDevice.Get()->CreateRenderTargetView(pResource, &rtvDesc, cpuHandle);
+        }
+
+        if (desc.Usage.HasFlag(TextureUsage.DepthStencil))
+        {
+            resourceDescriptor.dsv = _descriptorAllocator.AllocateDSV();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.dsv);
+            var dsvDesc = CreateDsvDesc(pResource);
+
+            _device.NativeDevice.Get()->CreateDepthStencilView(pResource, &dsvDesc, cpuHandle);
+        }
+
+        if (desc.Usage.HasFlag(TextureUsage.UnorderedAccess))
+        {
+            resourceDescriptor.uav = _descriptorAllocator.AllocateCbvSrvUav();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.uav);
+            var uavDesc = CreateTextureUavDesc(pResource);
+
+            _device.NativeDevice.Get()->CreateUnorderedAccessView(pResource, null, &uavDesc, cpuHandle);
+            _descriptorAllocator.CopyToShaderVisible(resourceDescriptor.uav);
+        }
+
+        var barrierData = new ResourceBarrierData
+        {
+            access = BarrierAccess.NoAccess,
+            layout = BarrierLayout.Common,
+            sync = BarrierSync.None
+        };
+
+        Handle<GPUResource> resource;
+        if (isSubAllocation)
+        {
+            resource = _resourceDatabase.ImportExternalResource(pResource, barrierData, resourceDescriptor, name);
+        }
+        else
+        {
+            resource = TrackAllocation(pAllocation, barrierData, resourceDescriptor, ResourceDesc.Texture(desc), name, isTemp);
+        }
+
+        return resource.AsTexture();
+    }
+
+    public Handle<Texture> CreateRenderTarget(ref readonly RenderTargetDesc desc, string name, CreationOptions options = default)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var textureDesc = desc.ToTextureDescription();
+        return CreateTexture(in textureDesc, name, options);
+    }
+
+    public Handle<GraphicsBuffer> CreateBuffer(ref readonly BufferDesc desc, string name, CreationOptions options = default)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        CheckBufferSize(desc.Size);
+
+        var resourceDesc = desc.ToD3D12ResourceDesc();
+        var isRaw = desc.Usage.HasFlag(BufferUsage.Raw);
+
+        var allocationDesc = new D3D12MA_ALLOCATION_DESC
+        {
+            HeapType = ConvertMemoryType(desc.MemoryType),
+            Flags = D3D12MA_ALLOCATION_FLAG_NONE,
+        };
+
+        var isSubAllocation = options.Heap.IsValid;
+        D3D12MA_Allocation* pAllocation = default;
+        ID3D12Resource* pResource = default;
+        HRESULT hr;
+
+        var initialState = desc.MemoryType switch
+        {
+            ResourceMemoryType.Default => D3D12_RESOURCE_STATE_COMMON,
+            ResourceMemoryType.Upload => D3D12_RESOURCE_STATE_GENERIC_READ,
+            ResourceMemoryType.Readback => D3D12_RESOURCE_STATE_COPY_DEST,
+            _ => D3D12_RESOURCE_STATE_COMMON
+        };
+
+        if (isSubAllocation)
+        {
+            hr = CreateResource(&allocationDesc, &resourceDesc, initialState, options, __uuidof(pResource), (void**)&pResource);
+        }
+        else
+        {
+            hr = CreateResource(&allocationDesc, &resourceDesc, initialState, options, null, (void**)&pAllocation);
+            pResource = pAllocation->GetResource();
+        }
+
+        if (hr.FAILED)
+        {
+#if DEBUG
+            ThrowIfFailed(hr);
+#endif
+            return Handle<GraphicsBuffer>.Invalid;
+        }
+
+        var isTemp = options.AllocationType == ResourceAllocationType.Temporary;
+        var resourceDescriptor = ResourceViewGroup.Invalid;
+
+        if (desc.Usage.HasFlag(BufferUsage.Constant))
+        {
+            resourceDescriptor.cbv = _descriptorAllocator.AllocateCbvSrvUav();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.cbv);
+            var cbvDesc = new D3D12_CONSTANT_BUFFER_VIEW_DESC
+            {
+                BufferLocation = pResource->GetGPUVirtualAddress(),
+                SizeInBytes = (uint)resourceDesc.Width,
+            };
+
+            _device.NativeDevice.Get()->CreateConstantBufferView(&cbvDesc, cpuHandle);
+            _descriptorAllocator.CopyToShaderVisible(resourceDescriptor.cbv);
+        }
+
+        if (desc.Usage.HasFlag(BufferUsage.ShaderResource))
+        {
+            resourceDescriptor.srv = _descriptorAllocator.AllocateCbvSrvUav();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.srv);
+            var srvDesc = CreateBufferSrvDesc(pResource, desc.Stride, isRaw);
+
+            _device.NativeDevice.Get()->CreateShaderResourceView(pResource, &srvDesc, cpuHandle);
+            _descriptorAllocator.CopyToShaderVisible(resourceDescriptor.srv);
+        }
+
+        if (desc.Usage.HasFlag(BufferUsage.UnorderedAccess))
+        {
+            resourceDescriptor.uav = _descriptorAllocator.AllocateCbvSrvUav();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(resourceDescriptor.uav);
+            var uavDesc = CreateBufferUavDesc(pResource, desc.Stride, isRaw);
+
+            _device.NativeDevice.Get()->CreateUnorderedAccessView(pResource, null, &uavDesc, cpuHandle);
+            _descriptorAllocator.CopyToShaderVisible(resourceDescriptor.uav);
+        }
+
+        var barrierData = new ResourceBarrierData
+        {
+            access = BarrierAccess.NoAccess,
+            layout = BarrierLayout.Undefined,
+            sync = BarrierSync.None
+        };
+
+        Handle<GPUResource> resource;
+        if (isSubAllocation)
+        {
+            resource = _resourceDatabase.ImportExternalResource(pResource, barrierData, resourceDescriptor, name);
+        }
+        else
+        {
+            resource = TrackAllocation(pAllocation, barrierData, resourceDescriptor, ResourceDesc.Buffer(desc), name, isTemp);
+        }
+
+        return resource.AsGraphicsBuffer();
+    }
+
+    public Handle<GraphicsBuffer> CreateTempUploadBuffer(ulong sizeInBytes, out ulong offset)
+    {
+        if (sizeInBytes <= _MAX_RESOURCE_SIZE_TO_FIT_IN_UPLOAD_BATCH && sizeInBytes + _uploadBatchOffset <= _UPLOAD_BATCH_SIZE)
+        {
+            offset = _uploadBatchOffset;
+            _uploadBatchOffset += sizeInBytes;
+            return _uploadBatch;
+        }
+        else
+        {
+            var bufferDesc = new BufferDesc
+            {
+                Size = (uint)sizeInBytes,
+                Usage = BufferUsage.Upload,
+                MemoryType = ResourceMemoryType.Upload,
+            };
+
+            var options = new CreationOptions
+            {
+                AllocationType = ResourceAllocationType.Temporary,
+            };
+
+            offset = 0;
+            return CreateBuffer(in bufferDesc, "TempUploadBuffer", options);
+        }
+    }
+
+    public Identifier<Sampler> CreateSampler(ref readonly SamplerDesc desc)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (_resourceDatabase.TryGetSampler(in desc, out var id))
+        {
+            return id;
+        }
+
+        var samplerDesc = new D3D12_SAMPLER_DESC
+        {
+            Filter = desc.FilterMode.ToD3D12Filter(),
+            AddressU = desc.AddressU.ToD3D12TextureAddressMode(),
+            AddressV = desc.AddressV.ToD3D12TextureAddressMode(),
+            AddressW = desc.AddressW.ToD3D12TextureAddressMode(),
+            MipLODBias = desc.MipLODBias,
+            MaxAnisotropy = desc.MaxAnisotropy,
+            ComparisonFunc = desc.ComparisonFunc.ToD3D12ComparisonFunc(),
+            MinLOD = desc.MinLOD,
+            MaxLOD = desc.MaxLOD,
+        };
+
+        var samplerDescriptor = _descriptorAllocator.AllocateSampler();
+        var cpuHandle = _descriptorAllocator.GetCpuHandle(samplerDescriptor);
+        _device.NativeDevice.Get()->CreateSampler(&samplerDesc, cpuHandle);
+        _descriptorAllocator.CopyToShaderVisible(samplerDescriptor);
+
+        return _resourceDatabase.CreateSampler(in desc, samplerDescriptor.Value);
+    }
+
+    public Handle<Mesh> CreateMesh(UnsafeList<Vertex> vertices, UnsafeList<uint> indices)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var vertexBufferDesc = new BufferDesc
+        {
+            Size = (uint)(vertices.Count * sizeof(Vertex)),
+            Stride = (uint)sizeof(Vertex),
+            Usage = BufferUsage.Vertex | BufferUsage.ShaderResource | BufferUsage.Raw,
+            MemoryType = ResourceMemoryType.Default,
+        };
+
+        var indexBufferDesc = new BufferDesc
+        {
+            Size = (uint)(indices.Count * sizeof(uint)),
+            Stride = sizeof(uint),
+            Usage = BufferUsage.Index | BufferUsage.ShaderResource | BufferUsage.Raw,
+            MemoryType = ResourceMemoryType.Default,
+        };
+
+        var objectBufferDesc = new BufferDesc
+        {
+            Size = (uint)sizeof(PerObjectData),
+            Stride = (uint)sizeof(PerObjectData),
+            Usage = BufferUsage.Raw | BufferUsage.ShaderResource,
+            MemoryType = ResourceMemoryType.Default,
+        };
+
+        var vertexBuffer = CreateBuffer(in vertexBufferDesc, "VertexBuffer");
+        var indexBuffer = CreateBuffer(in indexBufferDesc, "IndexBuffer");
+        var objectBuffer = CreateBuffer(in objectBufferDesc, "ObjectBuffer");
+
+        var data = new Mesh
+        {
+            Vertices = vertices,
+            Indices = indices,
+            VertexBuffer = vertexBuffer,
+            IndexBuffer = indexBuffer,
+            ObjectDataBuffer = objectBuffer,
+        };
+
+        return _resourceDatabase.AddMesh(in data);
+    }
+
+    public Handle<Material> CreateMaterial(Identifier<Shader> shader)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var material = new Material();
+        if (material.SetShader(shader, this, _resourceDatabase) != Error.None)
+        {
+            return Handle<Material>.Invalid;
+        }
+
+        return _resourceDatabase.AddMaterial(in material);
+    }
+
+    public Identifier<Shader> CreateGraphicsShader(ShaderDescriptor descriptor)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var shader = new Shader(descriptor);
+        return _resourceDatabase.AddShader(shader);
+    }
+
+    public void ReleaseTempResources()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        while (_tempResources.Count > 0)
+        {
+            var handle = _tempResources.Peek();
+            var r = _resourceDatabase.GetResourceRecord(handle);
+            if (r.IsFailure || !r.Value.Allocated)
+            {
+                // Resource already released or invalid, just dequeue
+                _tempResources.Dequeue();
+                continue;
+            }
+
+            if (r.Value.cpuFenceValue > _fenceSynchronizer.GPUFenceValue)
+            {
+                // Resource still in use by GPU, stop processing.
+                // Since resources are enqueued in order, we can break here.
+                break;
+            }
+
+            _resourceDatabase.ReleaseResource(handle);
+            _tempResources.Dequeue();
+        }
+
+        _uploadBatchOffset = 0;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        Debug.Assert(_tempResources.Count == 0, "Temporary resources should be released before disposing the allocator.");
+
+        foreach (var handle in _tempResources)
+        {
+            _resourceDatabase.ReleaseResource(handle);
+        }
+
+        _resourceDatabase.ReleaseResource(_uploadBatch.AsResource());
+
+        _d3d12MA.Dispose();
+        _tempResources.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12ResourceDatabase.cs

@@ -0,0 +1,499 @@
+using Ghost.Core;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.Collections;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using TerraFX.Interop.DirectX;
+
+namespace Ghost.Graphics.D3D12;
+
+// TODO: Thread safety
+internal class D3D12ResourceDatabase : IResourceDatabase
+{
+    internal unsafe record struct ResourceRecord
+    {
+        [StructLayout(LayoutKind.Explicit)]
+        public struct ResourceUnion
+        {
+            [FieldOffset(0)]
+            public UniquePtr<D3D12MA_Allocation> allocation;
+            [FieldOffset(0)]
+            public UniquePtr<ID3D12Resource> resource;
+
+            public ResourceUnion(D3D12MA_Allocation* allocation)
+            {
+                this.allocation = allocation;
+            }
+
+            public ResourceUnion(ID3D12Resource* resource)
+            {
+                this.resource = resource;
+            }
+        }
+
+        public ResourceDesc desc;
+        public ResourceViewGroup viewGroup;
+        public ResourceUnion resource;
+
+        public ResourceBarrierData barrierData;
+
+        public uint cpuFenceValue;
+        public readonly bool isExternal;
+
+        public readonly bool Allocated => isExternal ? resource.resource.Get() != null : resource.allocation.Get() != null;
+        public readonly SharedPtr<ID3D12Resource> ResourcePtr => isExternal ? resource.resource.Get() : resource.allocation.Get()->GetResource();
+
+        public ResourceRecord(D3D12MA_Allocation* allocation, uint cpuFenceValue, ResourceBarrierData barrierData, ResourceViewGroup resourceDescriptor, ResourceDesc desc)
+        {
+            this.resource = new ResourceUnion(allocation);
+            this.isExternal = false;
+
+            this.viewGroup = resourceDescriptor;
+            this.cpuFenceValue = cpuFenceValue;
+            this.barrierData = barrierData;
+            this.desc = desc;
+        }
+
+        public ResourceRecord(ID3D12Resource* resource, ResourceBarrierData barrierData, ResourceViewGroup viewGroup)
+        {
+            this.resource = new ResourceUnion(resource);
+            this.isExternal = true;
+
+            this.viewGroup = viewGroup;
+            this.cpuFenceValue = ~0u;
+            this.barrierData = barrierData;
+            this.desc = resource->GetDesc().ToResourceDesc();
+        }
+
+        public readonly uint Release(D3D12DescriptorAllocator descriptorAllocator)
+        {
+            var refCount = 0u;
+            if (Allocated)
+            {
+                if (isExternal)
+                {
+                    refCount = resource.resource.Get()->Release();
+                }
+                else
+                {
+                    refCount = resource.allocation.Get()->Release();
+                }
+            }
+
+            descriptorAllocator.Release(viewGroup);
+            return refCount;
+        }
+    }
+
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+
+    private UnsafeSlotMap<ResourceRecord> _resources;
+#if DEBUG || GHOST_EDITOR
+    private readonly Dictionary<Handle<GPUResource>, string> _resourceName;
+#endif
+
+    private UnsafeHashMap<SamplerDesc, Identifier<Sampler>> _samplers;
+    private UnsafeSlotMap<Mesh> _meshes;
+    private UnsafeSlotMap<Material> _materials;
+    private readonly DynamicArray<Shader> _shaders; // TODO: Use SlotMap?
+
+    private bool _disposed;
+
+    public D3D12ResourceDatabase(D3D12DescriptorAllocator descriptorAllocator)
+    {
+        _descriptorAllocator = descriptorAllocator;
+
+        _resources = new UnsafeSlotMap<ResourceRecord>(64, Allocator.Persistent, AllocationOption.Clear);
+#if DEBUG || GHOST_EDITOR
+        _resourceName = new Dictionary<Handle<GPUResource>, string>(64);
+#endif
+        _samplers = new UnsafeHashMap<SamplerDesc, Identifier<Sampler>>(32, Allocator.Persistent);
+        _meshes = new UnsafeSlotMap<Mesh>(64, Allocator.Persistent, AllocationOption.Clear);
+        _materials = new UnsafeSlotMap<Material>(16, Allocator.Persistent, AllocationOption.Clear);
+        _shaders = new DynamicArray<Shader>(16);
+    }
+
+    ~D3D12ResourceDatabase()
+    {
+        Dispose();
+    }
+
+    private void ReleaseResource<T>(ref T resource)
+        where T : IResourceReleasable
+    {
+        resource.ReleaseResource(this);
+        resource = default!;
+    }
+
+    public unsafe Handle<GPUResource> ImportExternalResource(ID3D12Resource* pResource, ResourceBarrierData initialBarrierData, ResourceViewGroup viewGroup, string? name = null)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (pResource == null)
+        {
+#if DEBUG
+            System.Diagnostics.Debugger.Break();
+#endif
+            return Handle<GPUResource>.Invalid;
+        }
+
+        var id = _resources.Add(new ResourceRecord(pResource, initialBarrierData, viewGroup), out var generation);
+        var handle = new Handle<GPUResource>(id, generation);
+
+#if DEBUG || GHOST_EDITOR
+        if (!string.IsNullOrEmpty(name))
+        {
+            pResource->SetName(name);
+            _resourceName[handle] = name;
+        }
+#endif
+
+        return handle;
+    }
+
+    public unsafe Handle<GPUResource> AddAllocation(D3D12MA_Allocation* allocation, uint cpuFenceValue, ResourceBarrierData initialBarrierData, ResourceViewGroup resourceDescriptor, ResourceDesc desc, string? name = null)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (allocation == null)
+        {
+#if DEBUG
+            System.Diagnostics.Debugger.Break();
+#endif
+            return Handle<GPUResource>.Invalid;
+        }
+
+        var id = _resources.Add(new ResourceRecord(allocation, cpuFenceValue, initialBarrierData, resourceDescriptor, desc), out var generation);
+        var handle = new Handle<GPUResource>(id, generation);
+
+#if DEBUG || GHOST_EDITOR
+        if (!string.IsNullOrEmpty(name))
+        {
+            allocation->SetName(name);
+            var pResource = allocation->GetResource();
+            if (pResource != null)
+            {
+                pResource->SetName(name);
+            }
+            _resourceName[handle] = name;
+        }
+#endif
+
+        return handle;
+    }
+
+    public bool HasResource(Handle<GPUResource> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _resources.Contains(handle.ID, handle.Generation);
+    }
+
+    public RefResult<ResourceRecord, Error> GetResourceRecord(Handle<GPUResource> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        ref var info = ref _resources.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        return RefResult<ResourceRecord, Error>.Success(ref info);
+    }
+
+    public SharedPtr<ID3D12Resource> GetResource(Handle<GPUResource> handle)
+    {
+        var r = GetResourceRecord(handle);
+        if (r.IsFailure)
+        {
+            return null;
+        }
+
+        return r.Value.ResourcePtr;
+    }
+
+    public Result<ResourceBarrierData, Error> GetResourceBarrierData(Handle<GPUResource> handle)
+    {
+        var r = GetResourceRecord(handle);
+        if (r.IsFailure)
+        {
+            return r.Error;
+        }
+
+        return r.Value.barrierData;
+    }
+
+    public Error SetResourceBarrierData(Handle<GPUResource> handle, ResourceBarrierData data)
+    {
+        var r = GetResourceRecord(handle);
+        if (r.IsFailure)
+        {
+            return r.Error;
+        }
+
+        r.Value.barrierData = data;
+        return Error.None;
+    }
+
+    public Result<ResourceDesc, Error> GetResourceDescription(Handle<GPUResource> handle)
+    {
+        var r = GetResourceRecord(handle);
+        if (r.IsFailure)
+        {
+            return r.Error;
+        }
+
+        return r.Value.desc;
+    }
+
+    public uint GetBindlessIndex(Handle<GPUResource> handle, BindlessAccess access = BindlessAccess.ShaderResource)
+    {
+        var r = GetResourceRecord(handle);
+        if (r.IsFailure || !r.Value.Allocated)
+        {
+            return ~0u;
+        }
+
+        return access switch
+        {
+            BindlessAccess.ShaderResource => (uint)r.Value.viewGroup.srv.Value,
+            BindlessAccess.ConstantBuffer => (uint)r.Value.viewGroup.cbv.Value,
+            BindlessAccess.UnorderedAccess => (uint)r.Value.viewGroup.uav.Value,
+            _ => ~0u,
+        };
+    }
+
+    public string? GetResourceName(Handle<GPUResource> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+#if DEBUG || GHOST_EDITOR
+        if (_resourceName.TryGetValue(handle, out var name))
+        {
+            return name;
+        }
+#endif
+        return null;
+    }
+
+    // FIX: This should be queued to be released after GPU is done with it.
+    public void ReleaseResource(Handle<GPUResource> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (!handle.IsValid)
+        {
+            return;
+        }
+
+        ref var info = ref _resources.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist || !info.Allocated)
+        {
+            return;
+        }
+
+        info.Release(_descriptorAllocator);
+#if DEBUG || GHOST_EDITOR
+        _resourceName.Remove(handle, out var name);
+#endif
+
+        _resources.Remove(handle.ID, handle.Generation);
+    }
+
+    public Identifier<Sampler> CreateSampler(ref readonly SamplerDesc desc, int id)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (_samplers.ContainsKey(desc))
+        {
+            throw new InvalidOperationException("Sampler already exists.");
+        }
+
+        var identifier = new Identifier<Sampler>(id);
+        _samplers.Add(desc, identifier);
+
+        return identifier;
+    }
+
+    public bool TryGetSampler(ref readonly SamplerDesc desc, out Identifier<Sampler> id)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _samplers.TryGetValue(desc, out id);
+    }
+
+    public void ReleaseSampler(Identifier<Sampler> id)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        // NOTE: We almost never release samplers individually, because they are cheap and can be reused.
+        // Ideally we would release all samplers at once when disposing the ResourceDatabase.
+        _descriptorAllocator.Release(new Identifier<SamplerDescriptor>(id.Value));
+    }
+
+    public Handle<Mesh> AddMesh(ref readonly Mesh mesh)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var id = _meshes.Add(mesh, out var generation);
+        return new Handle<Mesh>(id, generation);
+    }
+
+    public bool HasMesh(Handle<Mesh> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _meshes.Contains(handle.ID, handle.Generation);
+    }
+
+    public RefResult<Mesh, Error> GetMeshReference(Handle<Mesh> handle)
+    {
+        ref var mesh = ref _meshes.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        return RefResult<Mesh, Error>.Success(ref mesh);
+    }
+
+    public void ReleaseMesh(Handle<Mesh> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        ref var mesh = ref _meshes.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return;
+        }
+
+        ReleaseResource(ref mesh);
+        _meshes.Remove(handle.ID, handle.Generation);
+    }
+
+    public Handle<Material> AddMaterial(ref readonly Material material)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var id = _materials.Add(material, out var generation);
+        return new Handle<Material>(id, generation);
+    }
+
+    public bool HasMaterial(Handle<Material> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _materials.Contains(handle.ID, handle.Generation);
+    }
+
+    public RefResult<Material, Error> GetMaterialReference(Handle<Material> handle)
+    {
+        ref var material = ref _materials.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        return RefResult<Material, Error>.Success(ref material);
+    }
+
+    public void ReleaseMaterial(Handle<Material> handle)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        ref var material = ref _materials.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return;
+        }
+
+        ReleaseResource(ref material);
+        _materials.Remove(handle.ID, handle.Generation);
+    }
+
+    public Identifier<Shader> AddShader(Shader shader)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var id = _shaders.Count;
+        _shaders.Add(shader);
+        return new Identifier<Shader>(id);
+    }
+
+    public bool HasShader(Identifier<Shader> id)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return id.Value >= 0 && id.Value < _shaders.Count;
+    }
+
+    public RefResult<Shader, Error> GetShaderReference(Identifier<Shader> id)
+    {
+        if (!HasShader(id))
+        {
+            return Error.NotFound;
+        }
+
+        return RefResult<Shader, Error>.Success(ref _shaders[id.Value]);
+    }
+
+    public void ReleaseShader(Identifier<Shader> id)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (!HasShader(id))
+        {
+            return;
+        }
+
+        ref var shader = ref _shaders[id.Value]!;
+        ReleaseResource(ref shader);
+    }
+
+    public void Dispose()
+    {
+        [DoesNotReturn]
+        [Conditional("DEBUG")]
+        static void ThrowMemoryLeakException(string resourceType, int count)
+        {
+            throw new MemoryLeakException($"ResourceAllocator is being disposed with {count} {resourceType} still registered. Ensure all resources are released before disposing.");
+        }
+
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (_resources.Count > 0)
+        {
+            ThrowMemoryLeakException("GPU resources", _resources.Count);
+        }
+
+        if (_meshes.Count > 0)
+        {
+            ThrowMemoryLeakException("meshes", _meshes.Count);
+        }
+
+        if (_materials.Count > 0)
+        {
+            ThrowMemoryLeakException("materials", _materials.Count);
+        }
+
+        // DSL are reference space, it will be managed by GC, so we don't throw exception here.
+        for (var i = 0; i < _shaders.Count; i++)
+        {
+            ref var shader = ref _shaders[i];
+            ReleaseResource(ref shader);
+        }
+
+        _resources.Dispose();
+        _samplers.Dispose();
+        _meshes.Dispose();
+        _materials.Dispose();
+
+        _disposed = true;
+
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/D3D12SwapChain.cs

@@ -0,0 +1,264 @@
+using Ghost.Core;
+using Ghost.Core.Utilities;
+using Ghost.Graphics.Contracts;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using TerraFX.Interop.DirectX;
+using TerraFX.Interop.Windows;
+using static TerraFX.Aliases.DXGI_Alias;
+
+namespace Ghost.Graphics.D3D12;
+
+/// <summary>
+/// D3D12 implementation of swap chain interface
+/// </summary>
+internal unsafe class D3D12SwapChain : ISwapChain
+{
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+    private readonly D3D12RenderDevice _renderDevice;
+
+    private UniquePtr<IDXGISwapChain4> _swapChain;
+    private UnsafeArray<Handle<Texture>> _backBuffers;
+
+    private readonly object? _compositionSurface;
+
+    private bool _disposed;
+
+    public uint Width
+    {
+        get; private set;
+    }
+
+    public uint Height
+    {
+        get; private set;
+    }
+
+    public float ScaleX
+    {
+        get; private set;
+    }
+
+    public float ScaleY
+    {
+        get; private set;
+    }
+
+    public D3D12SwapChain(D3D12ResourceDatabase resourceDatabase, D3D12DescriptorAllocator descriptorAllocator, D3D12RenderDevice device, SwapChainDesc desc, uint bufferCount)
+    {
+        Debug.Assert(bufferCount >= 2);
+
+        _resourceDatabase = resourceDatabase;
+        _descriptorAllocator = descriptorAllocator;
+        _renderDevice = device;
+
+        _backBuffers = new UnsafeArray<Handle<Texture>>((int)bufferCount, Allocator.Persistent);
+
+        Width = desc.Width;
+        Height = desc.Height;
+
+        var pSwapChian = CreateSwapChain(desc, bufferCount);
+        _swapChain.Attach(pSwapChian);
+
+        CreateBackBuffers();
+        SetScale(desc.ScaleX, desc.ScaleY);
+
+        if (desc.Target.Type == SwapChainTargetType.Composition)
+            _compositionSurface = desc.Target.CompositionSurface;
+    }
+
+    ~D3D12SwapChain()
+    {
+        Dispose();
+    }
+
+    private IDXGISwapChain4* CreateSwapChain(SwapChainDesc desc, uint bufferCount)
+    {
+        var swapChainDesc = new DXGI_SWAP_CHAIN_DESC1
+        {
+            Width = desc.Width,
+            Height = desc.Height,
+            Format = desc.Format.ToDXGIFormat(),
+            SampleDesc = new DXGI_SAMPLE_DESC(1, 0),
+            BufferUsage = DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_RENDER_TARGET_OUTPUT,
+            BufferCount = bufferCount,
+            Scaling = DXGI_SCALING_STRETCH,
+            SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD,
+            AlphaMode = DXGI_ALPHA_MODE_IGNORE,
+            Flags = (uint)DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING,
+            Stereo = false,
+        };
+
+        IDXGISwapChain1* pTempSwapChain = default;
+
+        var pFactory = _renderDevice.DXGIFactory.Get();
+        var pCommandQueue = _renderDevice.NativeGraphicsQueue.Get();
+
+        switch (desc.Target.Type)
+        {
+            case SwapChainTargetType.Composition:
+                ThrowIfFailed(pFactory->CreateSwapChainForComposition((IUnknown*)pCommandQueue, &swapChainDesc, null, &pTempSwapChain));
+
+                if (desc.Target.CompositionSurface != null)
+                {
+                    using var compositionSurface = ISwapChainPanelNative.FromSwapChainPanel(desc.Target.CompositionSurface);
+                    compositionSurface.SetSwapChain((nint)pTempSwapChain);
+                }
+
+                break;
+
+            case SwapChainTargetType.WindowHandle:
+                var swapChainFullscreenDesc = new DXGI_SWAP_CHAIN_FULLSCREEN_DESC
+                {
+                    Windowed = true,
+                };
+
+                pFactory->CreateSwapChainForHwnd(
+                    (IUnknown*)pCommandQueue,
+                    new HWND(desc.Target.WindowHandle.ToPointer()),
+                    &swapChainDesc,
+                    &swapChainFullscreenDesc,
+                    null,
+                    &pTempSwapChain);
+                break;
+
+            default:
+                throw new ArgumentException("Unsupported swap chain target type.");
+        }
+
+        IDXGISwapChain4* pSwapChain = default;
+        pTempSwapChain->QueryInterface(__uuidof(pSwapChain), (void**)&pSwapChain);
+        pTempSwapChain->Release();
+
+        return pSwapChain;
+    }
+
+    private void CreateBackBuffers()
+    {
+        for (uint i = 0; i < _backBuffers.Count; i++)
+        {
+            ID3D12Resource* pBackBuffer = default;
+            ThrowIfFailed(_swapChain.Get()->GetBuffer(i, __uuidof(pBackBuffer), (void**)&pBackBuffer));
+            pBackBuffer->SetName($"SwapChain_BackBuffer_{i}");
+
+            var rtv = _descriptorAllocator.AllocateRTV();
+            var cpuHandle = _descriptorAllocator.GetCpuHandle(rtv);
+            _renderDevice.NativeDevice.Get()->CreateRenderTargetView(pBackBuffer, null, cpuHandle);
+
+            var view = ResourceViewGroup.Invalid with
+            {
+                rtv = rtv
+            };
+
+            var barrierData = new ResourceBarrierData
+            {
+                access = BarrierAccess.NoAccess,
+                layout = BarrierLayout.Present,
+                sync = BarrierSync.None,
+            };
+
+            var handle = _resourceDatabase.ImportExternalResource(pBackBuffer, barrierData, view);
+            _backBuffers[i] = handle.AsTexture();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Handle<Texture> GetCurrentBackBuffer()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _backBuffers[_swapChain.Get()->GetCurrentBackBufferIndex()];
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ReadOnlySpan<Handle<Texture>> GetBackBuffers()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        return _backBuffers.AsSpan();
+    }
+
+    public void Present(bool vsync = true)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        var presentFlags = 0u;
+        var syncInterval = vsync ? 1u : 0u;
+
+        ThrowIfFailed(_swapChain.Get()->Present(syncInterval, presentFlags));
+    }
+
+    public void Resize(uint width, uint height)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (Width == width && Height == height)
+        {
+            return;
+        }
+
+        // Release old back buffers and render targets
+        for (var i = 0; i < _backBuffers.Count; i++)
+        {
+            _resourceDatabase.ReleaseResource(_backBuffers[i].AsResource());
+        }
+
+        ThrowIfFailed(_swapChain.Get()->ResizeBuffers((uint)_backBuffers.Count, width, height, DXGI_FORMAT_B8G8R8A8_UNORM, (uint)DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING));
+
+        Width = width;
+        Height = height;
+
+        CreateBackBuffers();
+    }
+
+    public void SetScale(float scaleX, float scaleY)
+    {
+        var inverseScaleX = 1.0f / scaleX;
+        var inverseScaleY = 1.0f / scaleY;
+
+        var inverseScaleMatrix = new DXGI_MATRIX_3X2_F
+        {
+            _11 = inverseScaleX, // Scale X
+            _22 = inverseScaleY, // Scale Y
+            _12 = 0.0f,
+            _21 = 0.0f,
+            _31 = 0.0f, // Offset X
+            _32 = 0.0f // Offset Y
+        };
+
+        _swapChain.Get()->SetMatrixTransform(&inverseScaleMatrix);
+
+        ScaleX = scaleX;
+        ScaleY = scaleY;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (_compositionSurface != null)
+        {
+            using var compositionSurface = ISwapChainPanelNative.FromSwapChainPanel(_compositionSurface);
+            compositionSurface.SetSwapChain(0);
+        }
+
+        for (var i = 0; i < _backBuffers.Count; i++)
+        {
+            _resourceDatabase.ReleaseResource(_backBuffers[i].AsResource());
+        }
+
+        _backBuffers.Dispose();
+        _swapChain.Dispose();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/Runtime/Ghost.Graphics/D3D12/ResourceViewGroup.cs

@@ -0,0 +1,28 @@
+using Ghost.Core;
+
+namespace Ghost.Graphics.D3D12;
+
+internal readonly struct RTVDescriptor;
+internal readonly struct DSVDescriptor;
+internal readonly struct CbvSrvUavDescriptor;
+internal readonly struct SamplerDescriptor;
+
+internal struct ResourceViewGroup
+{
+    public Identifier<RTVDescriptor> rtv;
+    public Identifier<DSVDescriptor> dsv;
+    public Identifier<CbvSrvUavDescriptor> srv;
+    public Identifier<CbvSrvUavDescriptor> cbv;
+    public Identifier<CbvSrvUavDescriptor> uav;
+    public Identifier<SamplerDescriptor> sampler;
+
+    public static ResourceViewGroup Invalid => new()
+    {
+        rtv = Identifier<RTVDescriptor>.Invalid,
+        dsv = Identifier<DSVDescriptor>.Invalid,
+        srv = Identifier<CbvSrvUavDescriptor>.Invalid,
+        cbv = Identifier<CbvSrvUavDescriptor>.Invalid,
+        uav = Identifier<CbvSrvUavDescriptor>.Invalid,
+        sampler = Identifier<SamplerDescriptor>.Invalid,
+    };
+}

src/Runtime/Ghost.Graphics/D3D12/Utilities/D3D12PipelineResource.cs

@@ -0,0 +1,24 @@
+using System.Runtime.CompilerServices;
+using TerraFX.Interop.DirectX;
+using Ghost.Graphics.Core;
+
+namespace Ghost.Graphics.D3D12.Utilities;
+
+internal unsafe static class D3D12PipelineResource
+{
+    private readonly static D3D12_INPUT_ELEMENT_DESC[] s_inputElementDescs = [
+        new D3D12_INPUT_ELEMENT_DESC{ SemanticName = (sbyte*)Vertex.Semantic.Position.GetUnsafePointer(), SemanticIndex = 0u, Format =  Vertex.Semantic.ALIGNED_FORMAT, InputSlot = 0u, AlignedByteOffset = 0u, InputSlotClass = D3D12_INPUT_CLASSIFICATION.D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, InstanceDataStepRate = 0 },
+        new D3D12_INPUT_ELEMENT_DESC{ SemanticName = (sbyte*)Vertex.Semantic.Normal.GetUnsafePointer(), SemanticIndex = 0u, Format =  Vertex.Semantic.ALIGNED_FORMAT, InputSlot = 0u, AlignedByteOffset = 16u, InputSlotClass = D3D12_INPUT_CLASSIFICATION.D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, InstanceDataStepRate = 0 },
+        new D3D12_INPUT_ELEMENT_DESC{ SemanticName = (sbyte*)Vertex.Semantic.Tangent.GetUnsafePointer(), SemanticIndex = 0u, Format =  Vertex.Semantic.ALIGNED_FORMAT, InputSlot = 0u, AlignedByteOffset = 32u, InputSlotClass = D3D12_INPUT_CLASSIFICATION.D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, InstanceDataStepRate = 0 },
+        new D3D12_INPUT_ELEMENT_DESC{ SemanticName = (sbyte*)Vertex.Semantic.Uv.GetUnsafePointer(), SemanticIndex = 0u, Format =  Vertex.Semantic.ALIGNED_FORMAT, InputSlot = 0u, AlignedByteOffset = 48u, InputSlotClass = D3D12_INPUT_CLASSIFICATION.D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, InstanceDataStepRate = 0 },
+        new D3D12_INPUT_ELEMENT_DESC{ SemanticName = (sbyte*)Vertex.Semantic.Color.GetUnsafePointer(), SemanticIndex = 0u, Format =  Vertex.Semantic.ALIGNED_FORMAT, InputSlot = 0u, AlignedByteOffset = 64u, InputSlotClass = D3D12_INPUT_CLASSIFICATION.D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, InstanceDataStepRate = 0 },
+    ];
+
+    public const DXGI_FORMAT SWAP_CHAIN_BACK_BUFFER_FORMAT = DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM;
+
+    public static D3D12_INPUT_LAYOUT_DESC InputLayoutDescription => new()
+    {
+        pInputElementDescs = (D3D12_INPUT_ELEMENT_DESC*)Unsafe.AsPointer(ref s_inputElementDescs[0]),
+        NumElements = (uint)s_inputElementDescs.Length
+    };
+}

src/Runtime/Ghost.Graphics/D3D12/Utilities/D3D12Utility.cs

@@ -0,0 +1,523 @@
+using Ghost.Core.Graphics;
+using Ghost.Graphics.RHI;
+using TerraFX.Interop.DirectX;
+
+using static TerraFX.Aliases.D3D12_Alias;
+using static TerraFX.Aliases.DXGI_Alias;
+
+namespace Ghost.Graphics.D3D12.Utilities;
+
+internal static unsafe class D3D12Utility
+{
+    public static void SetName<T>(ref this T obj, ReadOnlySpan<char> name)
+        where T : unmanaged, ID3D12Object.Interface
+    {
+        if (name.IsEmpty)
+        {
+            return;
+        }
+
+        fixed (char* pName = name)
+        {
+            obj.SetName(pName);
+        }
+    }
+
+    public static void SetName(ref this D3D12MA_Allocation obj, ReadOnlySpan<char> name)
+    {
+        if (name.IsEmpty)
+        {
+            return;
+        }
+
+        fixed (char* pName = name)
+        {
+            obj.SetName(pName);
+        }
+    }
+
+    public static TextureDimension ToTextureDimension(this D3D12_RESOURCE_DIMENSION dimension)
+    {
+        return dimension switch
+        {
+            D3D12_RESOURCE_DIMENSION.D3D12_RESOURCE_DIMENSION_TEXTURE1D => TextureDimension.Texture2D,
+            D3D12_RESOURCE_DIMENSION.D3D12_RESOURCE_DIMENSION_TEXTURE2D => TextureDimension.Texture2D,
+            D3D12_RESOURCE_DIMENSION.D3D12_RESOURCE_DIMENSION_TEXTURE3D => TextureDimension.Texture3D,
+            _ => throw new NotSupportedException($"Resource dimension {dimension} is not supported."),
+        };
+    }
+
+    public static DXGI_FORMAT ToDXGIFormat(this TextureFormat format)
+    {
+        return format switch
+        {
+            TextureFormat.Unknown => DXGI_FORMAT_UNKNOWN,
+            TextureFormat.R8G8B8A8_UNorm => DXGI_FORMAT_R8G8B8A8_UNORM,
+            TextureFormat.B8G8R8A8_UNorm => DXGI_FORMAT_B8G8R8A8_UNORM,
+            TextureFormat.R16G16B16A16_Float => DXGI_FORMAT_R16G16B16A16_FLOAT,
+            TextureFormat.R32G32B32A32_Float => DXGI_FORMAT_R32G32B32A32_FLOAT,
+            TextureFormat.D24_UNorm_S8_UInt => DXGI_FORMAT_D24_UNORM_S8_UINT,
+            TextureFormat.D32_Float => DXGI_FORMAT_D32_FLOAT,
+            _ => throw new NotSupportedException($"Texture format {format} is not supported."),
+        };
+    }
+
+    public static TextureFormat ToTextureFormat(this DXGI_FORMAT format)
+    {
+        return format switch
+        {
+            DXGI_FORMAT_R8G8B8A8_UNORM => TextureFormat.R8G8B8A8_UNorm,
+            DXGI_FORMAT_B8G8R8A8_UNORM => TextureFormat.B8G8R8A8_UNorm,
+            DXGI_FORMAT_R16G16B16A16_FLOAT => TextureFormat.R16G16B16A16_Float,
+            DXGI_FORMAT_R32G32B32A32_FLOAT => TextureFormat.R32G32B32A32_Float,
+            DXGI_FORMAT_D24_UNORM_S8_UINT => TextureFormat.D24_UNorm_S8_UInt,
+            DXGI_FORMAT_D32_FLOAT => TextureFormat.D32_Float,
+            _ => throw new NotSupportedException($"DXGI format {format} is not supported.")
+        };
+    }
+
+    public static D3D12_RESOURCE_STATES ToD3D12States(this ResourceState state)
+    {
+        var d3dStates = D3D12_RESOURCE_STATES.D3D12_RESOURCE_STATE_COMMON;
+
+        if (state.HasFlag(ResourceState.VertexAndConstantBuffer))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
+        }
+
+        if (state.HasFlag(ResourceState.IndexBuffer))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_INDEX_BUFFER;
+        }
+
+        if (state.HasFlag(ResourceState.RenderTarget))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_RENDER_TARGET;
+        }
+
+        if (state.HasFlag(ResourceState.UnorderedAccess))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+        }
+
+        if (state.HasFlag(ResourceState.DepthWrite))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_DEPTH_WRITE;
+        }
+
+        if (state.HasFlag(ResourceState.DepthRead))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_DEPTH_READ;
+        }
+
+        if (state.HasFlag(ResourceState.PixelShaderResource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        }
+
+        if (state.HasFlag(ResourceState.CopyDest))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_COPY_DEST;
+        }
+
+        if (state.HasFlag(ResourceState.CopySource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_COPY_SOURCE;
+        }
+
+        if (state.HasFlag(ResourceState.GenericRead))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_GENERIC_READ;
+        }
+
+        if (state.HasFlag(ResourceState.IndirectArgument))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
+        }
+
+        if (state.HasFlag(ResourceState.NonPixelShaderResource))
+        {
+            d3dStates |= D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
+        }
+
+        return d3dStates;
+    }
+
+    public static ResourceState ToResourceState(this D3D12_RESOURCE_STATES states)
+    {
+        var resourceState = ResourceState.Common;
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER))
+        {
+            resourceState |= ResourceState.VertexAndConstantBuffer;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_INDEX_BUFFER))
+        {
+            resourceState |= ResourceState.IndexBuffer;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_RENDER_TARGET))
+        {
+            resourceState |= ResourceState.RenderTarget;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_UNORDERED_ACCESS))
+        {
+            resourceState |= ResourceState.UnorderedAccess;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_DEPTH_WRITE))
+        {
+            resourceState |= ResourceState.DepthWrite;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_DEPTH_READ))
+        {
+            resourceState |= ResourceState.DepthRead;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE))
+        {
+            resourceState |= ResourceState.PixelShaderResource;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_COPY_DEST))
+        {
+            resourceState |= ResourceState.CopyDest;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_COPY_SOURCE))
+        {
+            resourceState |= ResourceState.CopySource;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_GENERIC_READ))
+        {
+            resourceState |= ResourceState.GenericRead;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT))
+        {
+            resourceState |= ResourceState.IndirectArgument;
+        }
+
+        if (states.HasFlag(D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE))
+        {
+            resourceState |= ResourceState.NonPixelShaderResource;
+        }
+
+        return resourceState;
+    }
+
+    public static D3D12_FILTER ToD3D12Filter(this TextureFilterMode filterMode)
+    {
+        return filterMode switch
+        {
+            TextureFilterMode.Point => D3D12_FILTER_MIN_MAG_MIP_POINT,
+            TextureFilterMode.Bilinear => D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT,
+            TextureFilterMode.Trilinear => D3D12_FILTER_MIN_MAG_MIP_LINEAR,
+            TextureFilterMode.Anisotropic => D3D12_FILTER_ANISOTROPIC,
+            _ => throw new ArgumentException($"Unknown texture filter mode: {filterMode}")
+        };
+    }
+
+    public static D3D12_TEXTURE_ADDRESS_MODE ToD3D12TextureAddressMode(this TextureAddressMode addressMode)
+    {
+        return addressMode switch
+        {
+            TextureAddressMode.Repeat => D3D12_TEXTURE_ADDRESS_MODE_WRAP,
+            TextureAddressMode.Mirror => D3D12_TEXTURE_ADDRESS_MODE_MIRROR,
+            TextureAddressMode.Clamp => D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
+            TextureAddressMode.Border => D3D12_TEXTURE_ADDRESS_MODE_BORDER,
+            TextureAddressMode.MirrorOnce => D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE,
+            _ => throw new ArgumentException($"Unknown texture address mode: {addressMode}")
+        };
+    }
+
+    public static D3D12_COMPARISON_FUNC ToD3D12ComparisonFunc(this ComparisonFunction func)
+    {
+        return func switch
+        {
+            ComparisonFunction.Never => D3D12_COMPARISON_FUNC_NEVER,
+            ComparisonFunction.Less => D3D12_COMPARISON_FUNC_LESS,
+            ComparisonFunction.Equal => D3D12_COMPARISON_FUNC_EQUAL,
+            ComparisonFunction.LessEqual => D3D12_COMPARISON_FUNC_LESS_EQUAL,
+            ComparisonFunction.Greater => D3D12_COMPARISON_FUNC_GREATER,
+            ComparisonFunction.NotEqual => D3D12_COMPARISON_FUNC_NOT_EQUAL,
+            ComparisonFunction.GreaterEqual => D3D12_COMPARISON_FUNC_GREATER_EQUAL,
+            ComparisonFunction.Always => D3D12_COMPARISON_FUNC_ALWAYS,
+            _ => throw new ArgumentException($"Unknown comparison function: {func}")
+        };
+    }
+
+    public static D3D12_COMPARISON_FUNC ToD3DCompare(this ZTest z)
+    {
+        return z switch
+        {
+            ZTest.Disabled => D3D12_COMPARISON_FUNC_NEVER,
+            ZTest.Less => D3D12_COMPARISON_FUNC_LESS,
+            ZTest.LessEqual => D3D12_COMPARISON_FUNC_LESS_EQUAL,
+            ZTest.Equal => D3D12_COMPARISON_FUNC_EQUAL,
+            ZTest.GreaterEqual => D3D12_COMPARISON_FUNC_GREATER_EQUAL,
+            ZTest.Greater => D3D12_COMPARISON_FUNC_GREATER,
+            ZTest.NotEqual => D3D12_COMPARISON_FUNC_NOT_EQUAL,
+            ZTest.Always => D3D12_COMPARISON_FUNC_ALWAYS,
+            _ => D3D12_COMPARISON_FUNC_LESS_EQUAL
+        };
+    }
+
+    public static D3D12_COMMAND_LIST_TYPE ToCommandListType(CommandBufferType type)
+    {
+        return type switch
+        {
+            CommandBufferType.Graphics => D3D12_COMMAND_LIST_TYPE_DIRECT,
+            CommandBufferType.Compute => D3D12_COMMAND_LIST_TYPE_COMPUTE,
+            CommandBufferType.Copy => D3D12_COMMAND_LIST_TYPE_COPY,
+            _ => throw new ArgumentException($"Unknown command buffer type: {type}")
+        };
+    }
+
+    public static D3D12_RESOURCE_FLAGS ToD3D12ResourceFlag(this TextureUsage usage)
+    {
+        var flags = D3D12_RESOURCE_FLAG_NONE;
+
+        if (usage.HasFlag(TextureUsage.RenderTarget))
+        {
+            flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+        }
+
+        if (usage.HasFlag(TextureUsage.DepthStencil))
+        {
+            flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+        }
+
+        if (usage.HasFlag(TextureUsage.UnorderedAccess))
+        {
+            flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+        }
+
+        return flags;
+    }
+
+    public static D3D12_RESOURCE_DESC ToD3D12ResourceDesc(this in TextureDesc desc)
+    {
+        var dxgiFormat = desc.Format.ToDXGIFormat();
+        var maxDimension = Math.Max(desc.Width, Math.Max(desc.Height, desc.Slice));
+        var mipLevels = desc.MipLevels == 0
+            ? (ushort)(1 + Math.Floor(Math.Log2(maxDimension)))
+            : (ushort)desc.MipLevels;
+
+        var resourceFlags = desc.Usage.ToD3D12ResourceFlag();
+        return desc.Dimension switch
+        {
+            TextureDimension.Texture2D => D3D12_RESOURCE_DESC.Tex2D(
+                                dxgiFormat,
+                                desc.Width,
+                                desc.Height,
+                                mipLevels: mipLevels,
+                                flags: resourceFlags),
+            TextureDimension.Texture3D => D3D12_RESOURCE_DESC.Tex3D(
+                                dxgiFormat,
+                                desc.Width,
+                                desc.Height,
+                                (ushort)desc.Slice,
+                                flags: resourceFlags),
+            TextureDimension.TextureCube => D3D12_RESOURCE_DESC.Tex2D(
+                                dxgiFormat,
+                                desc.Width,
+                                desc.Height,
+                                mipLevels: mipLevels,
+                                arraySize: 6,
+                                flags: resourceFlags),
+            TextureDimension.Texture2DArray => D3D12_RESOURCE_DESC.Tex2D(
+                                dxgiFormat,
+                                desc.Width,
+                                desc.Height,
+                                mipLevels: mipLevels,
+                                arraySize: (ushort)desc.Slice,
+                                flags: resourceFlags),
+            TextureDimension.TextureCubeArray => D3D12_RESOURCE_DESC.Tex2D(
+                                dxgiFormat,
+                                desc.Width,
+                                desc.Height,
+                                mipLevels: mipLevels,
+                                arraySize: (ushort)(desc.Slice * 6),
+                                flags: resourceFlags),
+            _ => throw new ArgumentException($"Unsupported texture dimension: {desc.Dimension}"),
+        };
+    }
+
+    public static D3D12_RESOURCE_FLAGS ToD3D12ResourceFlag(this BufferUsage usage)
+    {
+        var flags = D3D12_RESOURCE_FLAG_NONE;
+
+        if (usage.HasFlag(BufferUsage.Raw) || usage.HasFlag(BufferUsage.UnorderedAccess))
+        {
+            flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+        }
+
+        return flags;
+    }
+
+    public static D3D12_RESOURCE_DESC ToD3D12ResourceDesc(this in BufferDesc desc)
+    {
+        var alignedSize = desc.Size;
+        if (desc.Usage.HasFlag(BufferUsage.Constant))
+        {
+            // D3D12 CBV size must be 256-byte aligned
+            alignedSize = (uint)(desc.Size + 255) & ~255u;
+        }
+
+        var resourceFlags = desc.Usage.ToD3D12ResourceFlag();
+        return D3D12_RESOURCE_DESC.Buffer(alignedSize, resourceFlags);
+    }
+
+
+    public static ResourceDesc ToResourceDesc(this D3D12_RESOURCE_DESC desc)
+    {
+        if (desc.Dimension == D3D12_RESOURCE_DIMENSION.D3D12_RESOURCE_DIMENSION_BUFFER)
+        {
+            return ResourceDesc.Buffer(new BufferDesc
+            {
+                Size = (uint)desc.Width,
+                Stride = 0,
+                Usage = BufferUsage.None,
+                MemoryType = ResourceMemoryType.Default
+            });
+        }
+        else
+        {
+            return ResourceDesc.Texture(new TextureDesc
+            {
+                Width = (uint)desc.Width,
+                Height = desc.Height,
+                Slice = desc.DepthOrArraySize,
+                Format = desc.Format.ToTextureFormat(),
+                Dimension = desc.Dimension.ToTextureDimension(),
+                MipLevels = desc.MipLevels,
+                Usage = TextureUsage.None,
+            });
+        }
+    }
+
+
+    public static D3D12_RASTERIZER_DESC D3D12_RASTERIZER_DESC_CREATE(
+        D3D12_FILL_MODE fillMode,
+        D3D12_CULL_MODE cullMode,
+        bool frontCounterClockwise = false,
+        int depthBias = D3D12_DEFAULT_DEPTH_BIAS,
+        float depthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP,
+        float slopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS,
+        bool depthClipEnable = true,
+        bool multisampleEnable = true,
+        bool antialiasedLineEnable = false,
+        uint forcedSampleCount = 0,
+        D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF)
+    {
+        return new D3D12_RASTERIZER_DESC
+        {
+            FillMode = fillMode,
+            CullMode = cullMode,
+            FrontCounterClockwise = frontCounterClockwise ? TRUE : FALSE,
+            DepthBias = depthBias,
+            DepthBiasClamp = depthBiasClamp,
+            SlopeScaledDepthBias = slopeScaledDepthBias,
+            DepthClipEnable = depthClipEnable ? TRUE : FALSE,
+            MultisampleEnable = multisampleEnable ? TRUE : FALSE,
+            AntialiasedLineEnable = antialiasedLineEnable ? TRUE : FALSE,
+            ForcedSampleCount = forcedSampleCount,
+            ConservativeRaster = conservativeRaster
+        };
+    }
+
+    public static D3D12_RASTERIZER_DESC D3D12_RASTERIZER_DESC_CULL_NONE => D3D12_RASTERIZER_DESC_CREATE(D3D12_FILL_MODE_SOLID, D3D12_CULL_MODE_NONE);
+    public static D3D12_RASTERIZER_DESC D3D12_RASTERIZER_DESC_CULL_CLOCKWISE => D3D12_RASTERIZER_DESC_CREATE(D3D12_FILL_MODE_SOLID, D3D12_CULL_MODE_FRONT);
+    public static D3D12_RASTERIZER_DESC D3D12_RASTERIZER_DESC_CULL_COUNTER_CLOCKWISE => D3D12_RASTERIZER_DESC_CREATE(D3D12_FILL_MODE_SOLID, D3D12_CULL_MODE_BACK);
+    public static D3D12_RASTERIZER_DESC D3D12_RASTERIZER_DESC_WIREFRAME => D3D12_RASTERIZER_DESC_CREATE(D3D12_FILL_MODE_WIREFRAME, D3D12_CULL_MODE_NONE);
+
+
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_CREATE(D3D12_BLEND srcBlend, D3D12_BLEND destBlend)
+    {
+        var blendDesc = new D3D12_BLEND_DESC
+        {
+            AlphaToCoverageEnable = false,
+            IndependentBlendEnable = false
+        };
+
+        for (var i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+        {
+            blendDesc.RenderTarget[i].BlendEnable = srcBlend != D3D12_BLEND_ONE || destBlend != D3D12_BLEND_ZERO;
+            blendDesc.RenderTarget[i].LogicOp = D3D12_LOGIC_OP_NOOP;
+            blendDesc.RenderTarget[i].SrcBlend = srcBlend;
+            blendDesc.RenderTarget[i].DestBlend = destBlend;
+            blendDesc.RenderTarget[i].BlendOp = D3D12_BLEND_OP_ADD;
+            blendDesc.RenderTarget[i].SrcBlendAlpha = srcBlend;
+            blendDesc.RenderTarget[i].DestBlendAlpha = destBlend;
+            blendDesc.RenderTarget[i].BlendOpAlpha = D3D12_BLEND_OP_ADD;
+            blendDesc.RenderTarget[i].RenderTargetWriteMask = (byte)D3D12_COLOR_WRITE_ENABLE_ALL;
+        }
+
+        return blendDesc;
+    }
+
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_OPAQUE => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_ONE, D3D12_BLEND_ZERO);
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_ALPHA_BLEND => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA);
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_ADDITIVE => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_ONE);
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_MULTIPLY => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_DEST_COLOR, D3D12_BLEND_ZERO);
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_PREMULTIPLIED => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_ONE, D3D12_BLEND_INV_SRC_ALPHA);
+    public static D3D12_BLEND_DESC D3D12_BLEND_DESC_NON_PREMULTIPLIED => D3D12_BLEND_DESC_CREATE(D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA);
+
+
+    public static D3D12_DEPTH_STENCIL_DESC D3D12_DEPTH_STENCIL_DESC_CREATE(
+        bool depthEnable,
+        bool depthWriteEnable,
+        D3D12_COMPARISON_FUNC depthFunc,
+        bool stencilEnable = false,
+        byte stencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK,
+        byte stencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK,
+        D3D12_STENCIL_OP frontStencilFailOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_STENCIL_OP frontStencilDepthFailOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_STENCIL_OP frontStencilPassOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_COMPARISON_FUNC frontStencilFunc = D3D12_COMPARISON_FUNC_ALWAYS,
+        D3D12_STENCIL_OP backStencilFailOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_STENCIL_OP backStencilDepthFailOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_STENCIL_OP backStencilPassOp = D3D12_STENCIL_OP_KEEP,
+        D3D12_COMPARISON_FUNC backStencilFunc = D3D12_COMPARISON_FUNC_ALWAYS)
+    {
+        return new D3D12_DEPTH_STENCIL_DESC
+        {
+            DepthEnable = depthEnable,
+            DepthWriteMask = depthWriteEnable ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO,
+            DepthFunc = depthFunc,
+            StencilEnable = stencilEnable,
+            StencilReadMask = stencilReadMask,
+            StencilWriteMask = stencilWriteMask,
+            FrontFace = D3D12_DEPTH_STENCILOP_DESC_CREATE(frontStencilFailOp, frontStencilDepthFailOp, frontStencilPassOp, frontStencilFunc),
+            BackFace = D3D12_DEPTH_STENCILOP_DESC_CREATE(backStencilFailOp, backStencilDepthFailOp, backStencilPassOp, backStencilFunc)
+        };
+    }
+
+    public static D3D12_DEPTH_STENCIL_DESC D3D12_DEPTH_STENCIL_DESC_NONE => D3D12_DEPTH_STENCIL_DESC_CREATE(false, false, D3D12_COMPARISON_FUNC_LESS_EQUAL);
+    public static D3D12_DEPTH_STENCIL_DESC D3D12_DEPTH_STENCIL_DESC_READ => D3D12_DEPTH_STENCIL_DESC_CREATE(true, false, D3D12_COMPARISON_FUNC_LESS_EQUAL);
+    public static D3D12_DEPTH_STENCIL_DESC D3D12_DEPTH_STENCIL_DESC_REVERSE_Z => D3D12_DEPTH_STENCIL_DESC_CREATE(true, true, D3D12_COMPARISON_FUNC_GREATER_EQUAL);
+    public static D3D12_DEPTH_STENCIL_DESC D3D12_DEPTH_STENCIL_DESC_READ_REVERSE_Z => D3D12_DEPTH_STENCIL_DESC_CREATE(true, false, D3D12_COMPARISON_FUNC_GREATER_EQUAL);
+
+
+    public static D3D12_DEPTH_STENCILOP_DESC D3D12_DEPTH_STENCILOP_DESC_CREATE(
+        D3D12_STENCIL_OP stencilFailOp,
+        D3D12_STENCIL_OP stencilDepthFailOp,
+        D3D12_STENCIL_OP stencilPassOp,
+        D3D12_COMPARISON_FUNC stencilFunc)
+    {
+        return new D3D12_DEPTH_STENCILOP_DESC
+        {
+            StencilFailOp = stencilFailOp,
+            StencilDepthFailOp = stencilDepthFailOp,
+            StencilPassOp = stencilPassOp,
+            StencilFunc = stencilFunc
+        };
+    }
+
+    public static D3D12_DEPTH_STENCILOP_DESC D3D12_DEPTH_STENCILOP_DESC_DEFAULT => D3D12_DEPTH_STENCILOP_DESC_CREATE(D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS);
+}

src/Runtime/Ghost.Graphics/GPUResourceLeakException.cs

@@ -0,0 +1,19 @@
+using Misaki.HighPerformance.LowLevel;
+
+namespace Ghost.Graphics;
+
+internal unsafe class GPUResourceLeakException : Exception
+{
+    public GPUResourceLeakException(uint refCount, void* address, string name)
+        : base($"GPU resource leak detected! Resource '{name}' at address {(UIntPtr)address} has a reference count of {refCount} when it should be 0. This indicates that the resource was not properly released before being destroyed, which can lead to memory leaks and other issues. Please ensure that all references to this resource are released appropriately.")
+    {
+    }
+
+    public static void ThrowIfRefCountNonZero(uint refCount, void* address, string name)
+    {
+        if (refCount != 0)
+        {
+            throw new GPUResourceLeakException(refCount, address, name);
+        }
+    }
+}

src/Runtime/Ghost.Graphics/Ghost.Graphics.csproj

@@ -0,0 +1,51 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebugType>embedded</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <IsAotCompatible>True</IsAotCompatible>
+    <IsTrimmable>True</IsTrimmable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="runtime\win-x64\native\dxcompiler.dll" />
+    <None Remove="runtime\win-x64\native\dxil.dll" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="runtime\win-x64\native\dxcompiler.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="runtime\win-x64\native\dxil.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Misaki.HighPerformance.Analyzer" Version="1.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Misaki.HighPerformance.Image" Version="1.1.0" />
+    <PackageReference Include="TerraFX.Interop.D3D12MemoryAllocator" Version="3.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+        <ProjectReference Include="../../Runtime/Ghost.Core/Ghost.Core.csproj" />
+        <ProjectReference Include="../../Editor/Ghost.DSL/Ghost.DSL.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+</Project>